# Criando Pods Estáticos

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

---

<!-- overview -->


*Pods Estáticos* são gerenciados diretamente pelo `daemon` kubelet em um nó específico,
sem 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>
observando-os.
Ao contrário dos pods que são gerenciados pelo `Control Plane` (por exemplo, uma
<a class='glossary-tooltip' title='Gerencia uma aplicação replicada no seu cluster.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/workloads/controllers/deployment/' target='_blank' aria-label='Implantação'>Implantação</a>);
em vez disso, o kubelet observa cada Pod estático 
(e reinicia-os se falharem).

Pods estáticos estão sempre ligados a um <a class='glossary-tooltip' title='Um agente que é executado em cada nó no cluster. Ele garante que os contêineres estejam sendo executados em um Pod.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/reference/command-line-tools-reference/kubelet' target='_blank' aria-label='Kubelet'>Kubelet</a> em um nó específico.

O Kubelet tenta automaticamente criar um <a class='glossary-tooltip' title='An object in the API server that tracks a static pod on a kubelet.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/reference/glossary/?all=true#term-mirror-pod' target='_blank' aria-label='mirror Pod'>mirror Pod</a>
no servidor de API do Kubernetes para cada Pod estático.
Isso significa que os pods em execução em um nó são visíveis no servidor de API,
mas não podem ser controlados a partir daí.
Aos nomes de Pods será sufixados com o nome de host do nó, com um hífem a esquerda. 



<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4>Se você está executando um cluster Kubernetes, usando Pods estáticos para executar um Pod em cada Nó,
provávelmente você deveria estar usando um <a class='glossary-tooltip' title='Garante que uma cópia de um Pod esteja sendo executada em um conjunto de nós em um cluster.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/workloads/controllers/daemonset' target='_blank' aria-label='DaemonSet'>DaemonSet</a> em substituição.</div>



<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4>A <code>especificação</code> de um Pod estático não pode referir-se à outros objetos da API
(ex., <a class='glossary-tooltip' title='Fornece uma identidade para os processos que são executados em um Pod.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/tasks/configure-pod-container/configure-service-account/' target='_blank' aria-label='ServiceAccount'>ServiceAccount</a>,
<a class='glossary-tooltip' title='Um objeto da API usado para armazenar dados não-confidenciais em pares chave-valor. Pode ser consumido como variáveis de ambiente, argumentos de linha de comando, ou arquivos de configuração em um volume.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/configuration/configmap' target='_blank' aria-label='ConfigMap'>ConfigMap</a>,
<a class='glossary-tooltip' title='Armazena dados sensíveis, como senhas, tokens OAuth e chaves SSH.' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/configuration/secret/' target='_blank' aria-label='Secret'>Secret</a>, etc).</div>


## Antes de você começar

<p>Você precisa ter um cluster do Kubernetes e a ferramenta de linha de comando kubectl deve estar configurada para se comunicar com seu cluster. É recomendado executar esse tutorial em um cluster com pelo menos dois nós que não estejam atuando como hosts de camada de gerenciamento. Se você ainda não possui um cluster, pode criar um usando o <a href="/pt-br/docs/tasks/tools/#minikube">minikube</a> ou pode usar um dos seguintes ambientes:</p>
<ul>
<li><a href="https://labs.iximiuz.com/playgrounds?category=kubernetes&filter=all">iximiuz Labs</a></li>
<li><a href="https://killercoda.com/playgrounds/scenario/kubernetes">Killercoda</a></li>
<li><a href="https://kodekloud.com/public-playgrounds">KodeKloud</a></li>
</ul>
 
  <p>Para verificar a versão, digite  <code>kubectl version</code>.</p>


Esta página assume que você está usando um <a class='glossary-tooltip' title='Um agente de execução leve de contêineres criado especificamente para o Kubernetes' data-bs-toggle='tooltip' data-bs-placement='top' href='https://cri-o.io/#what-is-cri-o' target='_blank' aria-label='CRI-O'>CRI-O</a> para executar os Pods,
e que seus nós estão executando o sistema operacional Fedora.
Instruções para outras distribuições, ou instalações de Kubernetes, podem variar.

<!-- steps -->

## Crie um pod estático {#static-pod-creation}

Você pode configurar um Pod estático com um [arquivo de configuração hospedado no sistema de arquivos](/docs/tasks/configure-pod-container/static-pod/#configuration-files) ou um [arquivo de configuração hospedado na Web](/docs/tasks/configure-pod-container/static-pod/#pods-created-via-http).

### Manifesto do Pod estático hospedado no sistema de arquivos {#configuration-files}

Os manifestos, são definições de Pod padrão em formato JSON ou YAML em um diretório específico. Use o campo `staticPodPath: <diretório>` no
[arquivo de configuração do kubelet](/docs/reference/config-api/kubelet-config.v1beta1/),
que periodicamente varre o diretório e cria/exclui Pods estáticos conforme os arquivos YAML/JSON aparecem/desaparecem.
Observe que o Kubelet ignorará os arquivos começando com pontos ao varrer o diretório especificado.

Por exemplo, como iniciar um servidor Web simples como um Pod estático

1. Escolha um nó onde você deseja executar um Pod estático. Neste exemplo, é `my-node1`.

    ```shell
    ssh my-node1
    ```

2. Escolha um diretório, digamos `/etc/kubernetes/manifests` e coloque uma definição de pod para um servidor web lá, por exemplo `/etc/kubernetes/manifests/static-web.yaml`:

    ```shell
    # Execute este comando no nó onde o Kubelet está funcionando
    mkdir -p /etc/kubernetes/manifests/
    cat <<EOF >/etc/kubernetes/manifests/static-web.yaml
    apiVersion: v1
    kind: Pod
    metadata:
      name: static-web
      labels:
        role: myrole
    spec:
      containers:
        - name: web
          image: nginx
          ports:
            - name: web
              containerPort: 80
              protocol: TCP
    EOF
    ```

3. Configure seu kubelet no nó para usar este diretório executando-o com o argumento `--pod-manifest-path=/etc/kubernetes/manifests/`. No Fedora, edite o arquivo `/etc/kubernetes/kubelet` para incluir esta linha:

   ```
   KUBELET_ARGS="--cluster-dns=10.254.0.10 --cluster-domain=kube.local --pod-manifest-path=/etc/kubernetes/manifests/"
   ```
   ou adicione o campo `staticPodPath: <o diretótio>` no 
   [arquivo de configuração do kubelet](/docs/reference/config-api/kubelet-config.v1beta1/).

4. Reinicie o kubelet. No Fedora, você poderia executar:

   ```shell
   # Execute este comando no nó onde o kubelet está funcionando
   systemctl restart kubelet
   ```

### Manifesto do Pod estático hospedado na Web {#pods-created-via-http}

O Kubelet baixa periodicamente um arquivo especificado pelo argumento `--manifest-url=<URL>` 
e interpreta-o como um arquivo JSON/YAML que contém as definições do Pod.
Similar ao que [manifestos hospedados no sistema de arquivos](#configuration-files) fazem, o kubelet
reexamina o manifesto em um agendamento. Se houver alterações na lista de Pods estáticos, o kubelet aplica-os.

Para usar esta abordagem: 

1. Crie um arquivo YAML e armazene-o em um servidor da Web, para que você possa passar o URL desse arquivo para o Kubelet.

    ```yaml
    apiVersion: v1
    kind: Pod
    metadata:
      name: static-web
      labels:
        role: myrole
    spec:
      containers:
        - name: web
          image: nginx
          ports:
            - name: web
              containerPort: 80
              protocol: TCP
    ```

2. Configure o kubelet no seu nó selecionado para usar este manifesto da Web, executando-o com `--manifest-url=<manifest-url>`. No Fedora, edite `/etc/kubernetes/kubelet` para incluir esta linha:

    ```
    KUBELET_ARGS="--cluster-dns=10.254.0.10 --cluster-domain=kube.local --manifest-url=<manifest-url>"
    ```

3. Reinicie o Kubelet. No Fedora, você usaria:

    ```shell
    # Execute este comando no nó onde o kubelet está funcionando
    systemctl restart kubelet
    ```

## Observe o comportamento do Pod estático {#behavior-of-static-pods}

Quando o kubelet começa, inicia automaticamente todos os pods estáticos definidos. 
Como você definiu um Pod estático e reiniciou o kubelet, o novo pod estático deveria
já estar em execução.

Você pode ver os Contêineres em execução (incluindo os Pods estáticos) ao executar (no Nó):

```shell
# Execute este comando no nó onde o kubelet está funcionando
crictl ps
```

A saída pode ser algo como:

```console
CONTAINER       IMAGE                                 CREATED           STATE      NAME    ATTEMPT    POD ID
129fd7d382018   docker.io/library/nginx@sha256:...    11 minutes ago    Running    web     0          34533c6729106
```


<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4><code>crictl</code> mostra a URI da imagem e o checksum SHA-256. O <code>NAME</code> vai parecer mais como:
<code>docker.io/library/nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31</code>.</div>


Você pode ver o Pod espelho no servidor de API:

```shell
kubectl get pods
```
```
NAME         READY   STATUS    RESTARTS        AGE
static-web   1/1     Running   0               2m
```


<div class="alert alert-info" role="note"><h4 class="alert-heading">Nota</h4>Verifique se o Kubelet tem permissão para criar o Pod espelho no servidor de API. Caso contrário, a solicitação de criação é rejeitada pelo servidor de API. Veja <a href="/docs/concepts/security/pod-security-admission">Admissão de segurança do pod</a> e <a href="/pt-br/docs/concepts/security/pod-security-policy/">Políticas de Segurança de Pod</a>.</div>


Os <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='Rótulos'>Rótulos</a> dos pods estáticos são
propagados no Pod espelho. Você pode usar esses rótulos como 
<a class='glossary-tooltip' title='Permite ao usuário filtrar uma lista de recursos com base em rótulos (labels).' data-bs-toggle='tooltip' data-bs-placement='top' href='/pt-br/docs/concepts/overview/working-with-objects/labels/' target='_blank' aria-label='seletores'>seletores</a> via normal, etc.

Se você tentar usar o `kubectl` para excluir o Pod espelho do servidor de API,
o kubelet _não_ remove o Pod estático:

```shell
kubectl delete pod static-web
```
```
pod "static-web" deleted
```
Você pode ver que o Pod ainda está funcionando:
```shell
kubectl get pods
```
```
NAME         READY   STATUS    RESTARTS   AGE
static-web   1/1     Running   0          4s
```

De volta ao seu nó, onde o kubelet está funcionando, você pode tentar parar o Contêiner manualmente.
Você verá que, depois de algum tempo, o Kubelet notará e reiniciará o Pod
automaticamente:

```shell
# Execute esses comandos no nó onde o Kubelet está funcionando
crictl stop 129fd7d382018 # substitua pelo ID do seu contêiner
sleep 20
crictl ps
```
```console
CONTAINER       IMAGE                                 CREATED           STATE      NAME    ATTEMPT    POD ID
89db4553e1eeb   docker.io/library/nginx@sha256:...    19 seconds ago    Running    web     1          34533c6729106
```

## Adição e remoção dinâmica de Pods estáticos

O Kubelet em execução varre periodicamente o diretório configurado (`/etc/kubernetes/manifests` em nosso exemplo) por alterações, e adiciona/remove os pods à medida que os arquivos aparecem/desaparecem neste diretório.

```shell
# Pressupondo que você esteja usando a configuração de Pod estático hospedada no sistema de arquivos
# Execute esses comandos no nó onde o Kubelet está funcionando
#
mv /etc/kubelet.d/static-web.yaml /tmp
sleep 20
crictl ps
# Você vê que nenhum contêiner nginx está funcionando
#
mv /tmp/static-web.yaml  /etc/kubelet.d/
sleep 20
crictl ps
```
```console
CONTAINER       IMAGE                                 CREATED           STATE      NAME    ATTEMPT    POD ID
f427638871c35   docker.io/library/nginx@sha256:...    19 seconds ago    Running    web     1          34533c6729106
```
