kubernetes
/
website
mirror of https://github.com/kubernetes/website.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[pt-br] Update docs/setup/production-environment/tools/kubeadm/install-kubeadm.md (#46001) 

* Install Kubeadm page in Brazilian Portuguese is outdated

* Add missing check-required-ports anchor

* consolidate wording

Address feedback

Address feedback

* Update content/pt-br/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md

Co-authored-by: Mauren <698465+stormqueen1990@users.noreply.github.com>

* Update content/pt-br/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md

Co-authored-by: Mauren <698465+stormqueen1990@users.noreply.github.com>

---------

Co-authored-by: Mauren <698465+stormqueen1990@users.noreply.github.com>
This commit is contained in:
Ricardo Amaro 2024-05-13 01:57:15 +01:00 committed by GitHub
parent eeeb98af07
commit f0130b3f1e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 198 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

310
content/pt-br/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md
View File

@ -2,6 +2,10 @@
title: Instalando a ferramenta kubeadm title: Instalando a ferramenta kubeadm
content_type: task content_type: task
weight: 10 weight: 10
card:
name: setup
weight: 40
title: Instalar a ferramenta de configuração kubeadm
--- ---
<!-- overview --> <!-- overview -->
@ -9,6 +13,7 @@ weight: 10
<img src="https://raw.githubusercontent.com/kubernetes/kubeadm/master/logos/stacked/color/kubeadm-stacked-color.png" align="right" width="150px">Essa página mostra o processo de instalação do conjunto de ferramentas `kubeadm`. <img src="https://raw.githubusercontent.com/kubernetes/kubeadm/master/logos/stacked/color/kubeadm-stacked-color.png" align="right" width="150px">Essa página mostra o processo de instalação do conjunto de ferramentas `kubeadm`.
Para mais informações sobre como criar um cluster com o kubeadm após efetuar a instalação, veja a página [Utilizando kubeadm para criar um cluster](/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/). Para mais informações sobre como criar um cluster com o kubeadm após efetuar a instalação, veja a página [Utilizando kubeadm para criar um cluster](/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/).
{{< doc-versions-list "installation guide" >}}
## {{% heading "prerequisites" %}} ## {{% heading "prerequisites" %}}
@ -16,15 +21,29 @@ Para mais informações sobre como criar um cluster com o kubeadm após efetuar
* 2 GB ou mais de RAM por máquina (menos que isso deixará pouca memória para as suas aplicações). * 2 GB ou mais de RAM por máquina (menos que isso deixará pouca memória para as suas aplicações).
* 2 CPUs ou mais. * 2 CPUs ou mais.
* Conexão de rede entre todas as máquinas no cluster. Seja essa pública ou privada. * Conexão de rede entre todas as máquinas no cluster. Seja essa pública ou privada.
* Nome da máquina na rede, endereço MAC e producy_uuid únicos para cada nó. Mais detalhes podem ser lidos [aqui](#veficiar-endereco-mac). * Nome de host único, endereço MAC e product_uuid para cada nó. Veja [aqui](#verify-mac-address) para mais detalhes.
* Portas específicas abertas nas suas máquinas. Você poderá ler quais são [aqui](#verificar-portas-necessarias). * Certas portas estão abertas em suas máquinas. Veja [aqui](#check-required-ports) para mais detalhes.
* Swap desabilitado. Você *precisa* desabilitar a funcionalidade de swap para que o kubelet funcione de forma correta. * Configuração de swap. O comportamento padrão do kubelet era falhar ao iniciar se a memória swap fosse detectada em um nó.
O suporte a swap foi introduzido a partir da v1.22. E desde a v1.28, o swap é suportado apenas para cgroup v2; o recurso NodeSwap
do kubelet está em beta, mas desativado por padrão.
* Você **DEVE** desabilitar o swap se o kubelet não estiver configurado corretamente para usar swap. Por exemplo, `sudo swapoff -a`
desabilitará a troca temporariamente. Para tornar essa mudança persistente entre reinicializações, certifique-se de que o swap esteja desabilitado em
arquivos de configuração como `/etc/fstab`, `systemd.swap`, dependendo de como foi configurado em seu sistema.
{{< note >}}
A instalação do `kubeadm` é feita via binários que usam linkagem dinâmica e assume que seu sistema alvo fornece `glibc`.
Essa é uma suposição razoável em muitas distribuições Linux (incluindo Debian, Ubuntu, Fedora, CentOS, etc.)
mas nem sempre é o caso com distribuições personalizadas e leves que não incluem `glibc` por padrão, como o Alpine Linux.
A expectativa é que a distribuição inclua `glibc` ou uma [camada de compatibilidade](https://wiki.alpinelinux.org/wiki/Running_glibc_programs)
que forneça os símbolos esperados.
{{< /note >}}
<!-- steps --> <!-- steps -->
## Verificando se o endereço MAC e o product_uiid são únicos para cada nó {#veficiar-endereco-mac}
* Você pode verificar o endereço MAC da interface de rede utilizando o comando `ip link` ou o comando `ipconfig -a`. ## Verifique se o endereço MAC e o product_uuid são únicos para cada nó {#verify-mac-address}
* Você pode obter o endereço MAC das interfaces de rede usando o comando `ip link` ou `ifconfig -a`.
* O product_uuid pode ser verificado utilizando o comando `sudo cat /sys/class/dmi/id/product_uuid`. * O product_uuid pode ser verificado utilizando o comando `sudo cat /sys/class/dmi/id/product_uuid`.
É provável que dispositivos físicos possuam endereços únicos. No entanto, é possível que algumas máquinas virtuais possuam endereços iguais. O Kubernetes utiliza esses valores para identificar unicamente os nós em um cluster. Se esses valores não forem únicos para cada nó, o processo de instalação pode [falhar](https://github.com/kubernetes/kubeadm/issues/31). É provável que dispositivos físicos possuam endereços únicos. No entanto, é possível que algumas máquinas virtuais possuam endereços iguais. O Kubernetes utiliza esses valores para identificar unicamente os nós em um cluster. Se esses valores não forem únicos para cada nó, o processo de instalação pode [falhar](https://github.com/kubernetes/kubeadm/issues/31).
@ -33,66 +52,70 @@ Para mais informações sobre como criar um cluster com o kubeadm após efetuar
Se você possuir mais de um adaptador de rede, e seus componentes Kubernetes não forem acessíveis através da rota padrão, recomendamos adicionar o IP das rotas para que os endereços do cluster Kubernetes passem pelo adaptador correto. Se você possuir mais de um adaptador de rede, e seus componentes Kubernetes não forem acessíveis através da rota padrão, recomendamos adicionar o IP das rotas para que os endereços do cluster Kubernetes passem pelo adaptador correto.
## Fazendo com que o iptables enxergue o tráfego agregado ## Verifique as portas necessárias {#check-required-ports}
Assegure-se de que o módulo `br_netfilter` está carregado. Isso pode ser feito executando o comando `lsmod | grep br_netfilter`. Para carrega-lo explicitamente execute `sudo modprobe br_netfilter`. Essas [portas necessárias](/docs/reference/networking/ports-and-protocols/)
precisam estar abertas para que os componentes do Kubernetes se comuniquem entre si.
Você pode usar ferramentas como [netcat](https://netcat.sourceforge.net) para verificar se uma porta está aberta. Por exemplo:
Como um requisito para que seus nós Linux enxerguem corretamente o tráfego agregado de rede, você deve garantir que a configuração `net.bridge.bridge-nf-call-iptables` do seu `sysctl` está configurada com valor 1. Como no exemplo abaixo: ```shell
nc 127.0.0.1 6443 -v
```bash
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sudo sysctl --system
``` ```
Para mais detalhes veja a página [Requisitos do plugin de rede](/pt-br/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/#network-plugin-requirements). O plugin de rede de Pods que você usa também pode exigir que certas portas estejam
abertas. Como isso varia com cada plugin de rede de Pods, consulte a
documentação dos plugins sobre quais portas precisam estar abertas.
## Verificando as portas necessárias ## Instalando um runtime de contêiner {#installing-runtime}
As portas listadas [aqui](https://kubernetes.io/docs/reference/ports-and-protocols/) precisam estar abertas para que os componentes do Kubernetes se comuniquem uns com os outros. Para executar contêiners em Pods, o Kubernetes usa um
{{< glossary_tooltip term_id="container-runtime" text="runtime de container" >}}.
O plugin de rede dos pods que você utiliza também pode requer que algumas portas estejam abertas. Dito que essas portas podem diferir dependendo do plugin, por favor leia a documentação dos plugins sobre quais portas serão necessárias abrir. Por padrão, o Kubernetes usa a
{{< glossary_tooltip term_id="cri" text="Interface de Runtime de Container">}} (CRI)
para se comunicar com o runtime de contêiner escolhido.
## Instalando o agente de execução de contêineres {#instalando-agente-de-execucao} Se você não especificar um runtime, o kubeadm tentará detectar automaticamente um runtime de contêiner instalado
varrendo uma lista de endpoints conhecidos.
Para executar os contêineres nos Pods, o Kubernetes utiliza um Se múltiplos ou nenhum runtime de contêiner forem detectados, o kubeadm lançará um erro
{{< glossary_tooltip term_id="container-runtime" text="agente de execução" >}}. e solicitará que você especifique qual deles deseja usar.
Veja [runtimes de container](/docs/setup/production-environment/container-runtimes/)
para mais informações.
{{< note >}}
O Docker Engine não implementa a [CRI](/docs/concepts/architecture/cri/)
que é um requisito para um runtime de contêiner trabalhar com o Kubernetes.
Por essa razão, um serviço adicional [cri-dockerd](https://mirantis.github.io/cri-dockerd/)
deve ser instalado. cri-dockerd é um projeto baseado no suporte integrado legado
do Docker Engine que foi [removido](/dockershim) do kubelet na versão 1.24.
{{< /note >}}
As tabelas abaixo incluem os endpoints conhecidos para sistemas operacionais suportados:
{{< tabs name="container_runtime" >}} {{< tabs name="container_runtime" >}}
{{% tab name="Nós Linux" %}} {{% tab name="Linux" %}}
Por padrão, o Kubernetes utiliza a {{< glossary_tooltip term_id="cri" text="interface do agente de execução">}} (CRI) para interagir com o seu agente de execução de contêiner escolhido. {{< table caption="Runtimes de contêiner para Linux" >}}
| Agente de execução | Caminho para o socket de domínio Unix |
Se você não especificar nenhum agente de execução, o kubeadm irá tentar identifica-lo automaticamente através de uma lista dos sockets Unix mais utilizados. A tabela a seguir lista os agentes de execução e os caminhos dos sockets a eles associados. |------------------------------------|---------------------------------------------------------|
| containerd | `unix:///var/run/containerd/containerd.sock` |
{{< table caption = "Agentes de execução e seus caminhos de socket" >}} | CRI-O | `unix:///var/run/crio/crio.sock` |
| Agente de execução | Caminho do socket Unix | | Docker Engine (usando cri-dockerd) | `unix:///var/run/cri-dockerd.sock` |
|------------|-----------------------------------|
| Docker | `/var/run/dockershim.sock` |
| containerd | `/run/containerd/containerd.sock` |
| CRI-O | `/var/run/crio/crio.sock` |
{{< /table >}} {{< /table >}}
<br />
Se tanto o Docker quanto o containerd forem detectados no sistema, o Docker terá precedência. Isso acontece porque o Docker, desde a versão 18.09, já incluí o containerd e ambos são detectaveis mesmo que você só tenha instalado o Docker. Se outros dois ou mais agentes de execução forem detectados, o kubeadm é encerrado com um erro.
O kubelet se integra com o Docker através da implementação CRI `dockershim` já inclusa.
Veja a página dos [agentes de execução](/docs/setup/production-environment/container-runtimes/)
para mais detalhes.
{{% /tab %}} {{% /tab %}}
{{% tab name="Outros sistemas operacionais" %}}
Por padrão, o kubeadm utiliza o {{< glossary_tooltip term_id="docker" >}} como agente de execução.
O kubelet se integra com o Docker através da implementação CRI `dockershim` já inclusa.
Veja a página dos [agentes de execução](/docs/setup/production-environment/container-runtimes/) {{% tab name="Windows" %}}
para mais detalhes.
{{< table caption="Runtimes de contêiner para Windows" >}}
| Runtime | Caminho para o pipe nomeado do Windows |
|------------------------------------|---------------------------------------------------------|
| containerd | `npipe:////./pipe/containerd-containerd` |
| Docker Engine (usando cri-dockerd) | `npipe:////./pipe/cri-dockerd` |
{{< /table >}}
{{% /tab %}} {{% /tab %}}
{{< /tabs >}} {{< /tabs >}}
@ -101,18 +124,20 @@ para mais detalhes.
Você instalará esses pacotes em todas as suas máquinas: Você instalará esses pacotes em todas as suas máquinas:
* `kubeadm`: o comando para criar o cluster. * `kubeadm`: o comando para iniciar o cluster.
* `kubelet`: o componente que executa em todas as máquinas no seu cluster e cuida de tarefas como a inicialização de pods e contêineres. * `kubelet`: o componente que executa em todas as máquinas do seu cluster
e faz coisas como iniciar Pods e contêiners.
* `kubectl`: a ferramenta de linha de comando para interação com o cluster. * `kubectl`: o utilitário de linha de comando para interagir com o cluster.
O kubeadm **não irá** instalar ou gerenciar o `kubelet` ou o `kubectl` para você, então você O kubeadm **não irá** instalar ou gerenciar o `kubelet` ou o `kubectl` para você, então você
precisará garantir que as versões deles são as mesmas da versão da camada de gerenciamento do Kubernetes precisará garantir que eles correspondam à versão da camada de gerenciamento do Kubernetes
que você quer que o kubeadm instale. Caso isso não seja feito, surge o risco de que uma diferença nas versões que você deseja que o `kubeadm` instale para você. Caso isso não seja feito, surge o risco de que uma diferença nas versões
leve a bugs e comportamentos inesperados. Dito isso, _uma_ diferença de menor grandeza nas versões entre o kubelet e a leve a bugs e comportamentos inesperados. Dito isso, _uma_ diferença de menor grandeza nas versões entre o kubelet e a
camada de gerenciamento é suportada, mas a versão do kubelet nunca poderá ser superior à versão do servidor da API. camada de gerenciamento é suportada, mas a versão do kubelet nunca poderá ser superior à versão do servidor da API.
Por exemplo, um kubelet com a versão 1.7.0 será totalmente compatível com a versão 1.8.0 do servidor da API, mas o contrário não será verdadeiro. Por exemplo, o kubelet executando 1.7.0 deve ser totalmente compatível com um servidor da API 1.8.0,
mas não o contrário.
Para mais informações acerca da instalação do `kubectl`, veja [Instale e configure o kubectl](/docs/tasks/tools/). Para mais informações acerca da instalação do `kubectl`, veja [Instale e configure o kubectl](/docs/tasks/tools/).
@ -123,29 +148,52 @@ Isso ocorre porque o kubeadm e o Kubernetes requerem alguns [cuidados especiais
Para mais detalhes sobre compatibilidade entre as versões, veja: Para mais detalhes sobre compatibilidade entre as versões, veja:
* [Políticas de versão e compatibilidade entre versões](/docs/setup/release/version-skew-policy/) do Kubernetes. * [Políticas de versão e compatibilidade entre versões](/docs/setup/release/version-skew-policy/) do Kubernetes
* [Compatibilidade entre versões](/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/#version-skew-policy) do Kubeadm. * [Política de descompasso de versão específica do Kubeadm](/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/#version-skew-policy)
{{% legacy-repos-deprecation %}}
{{< note >}}
Existe um repositório de pacotes dedicado para cada versão menor do Kubernetes. Se você deseja instalar
uma versão menor diferente da v{{< skew currentVersion >}}, por favor, veja o guia de instalação para
a sua versão menor desejada.
{{< /note >}}
{{< tabs name="k8s_install" >}} {{< tabs name="k8s_install" >}}
{{% tab name="Distribuições Debian" %}} {{% tab name="Distribuições baseadas em Debian" %}}
1. Atualize o índice de pacotes `apt` e instale os pacotes necessários para utilizar o repositório `apt` do Kubernetes: Essas instruções são para o Kubernetes v{{< skew currentVersion >}}.
1. Atualize o índice de pacotes `apt` e instale os pacotes necessários para usar o repositório `apt` do Kubernetes:
```shell ```shell
sudo apt-get update sudo apt-get update
# apt-transport-https pode ser um pacote fictício; se for, você pode pular esse pacote
sudo apt-get install -y apt-transport-https ca-certificates curl gpg sudo apt-get install -y apt-transport-https ca-certificates curl gpg
``` ```
2. Faça o download da chave de assinatura pública da Google Cloud: 2. Baixe a chave pública de assinatura para os repositórios de pacotes do Kubernetes.
A mesma chave de assinatura é usada para todos os repositórios, então você pode ignorar a versão na URL:
```shell ```shell
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg # Se o diretório `/etc/apt/keyrings` não existir, ele deve ser criado antes do comando curl, leia a nota abaixo.
# sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/{{< param "version" >}}/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
``` ```
3. Adicione o repositório `apt` do Kubernetes: {{< note >}}
Em lançamentos anteriores ao Debian 12 e Ubuntu 22.04, o diretório `/etc/apt/keyrings` não existe por padrão, e deve ser criado antes do comando curl.
{{< /note >}}
3. Adicione o repositório `apt` apropriado do Kubernetes. Por favor, note que este repositório tem pacotes
apenas para o Kubernetes {{< skew currentVersion >}}; para outras versões menores do Kubernetes, você precisa
mudar a versão menor do Kubernetes na URL para corresponder à sua versão menor desejada
(você também deve verificar se está lendo a documentação para a versão do Kubernetes
que você planeja instalar).
```shell ```shell
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list # Isso sobrescreve qualquer configuração existente em /etc/apt/sources.list.d/kubernetes.list
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/{{< param "version" >}}/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
``` ```
4. Atualize o índice de pacotes `apt`, instale o kubelet, o kubeadm e o kubectl, e fixe suas versões: 4. Atualize o índice de pacotes `apt`, instale o kubelet, o kubeadm e o kubectl, e fixe suas versões:
@ -156,98 +204,136 @@ Para mais detalhes sobre compatibilidade entre as versões, veja:
sudo apt-mark hold kubelet kubeadm kubectl sudo apt-mark hold kubelet kubeadm kubectl
``` ```
5. (Opcional) Habilite o serviço kubelet antes de executar o kubeadm:
```shell
sudo systemctl enable --now kubelet
```
{{% /tab %}} {{% /tab %}}
{{% tab name="Distribuições Red Hat" %}} {{% tab name="Distribuições baseadas em Red Hat" %}}
```bash
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
exclude=kubelet kubeadm kubectl
EOF
# Set SELinux in permissive mode (effectively disabling it) 1. Configure o SELinux em modo `permissivo`:
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes Essas instruções são para o Kubernetes {{< skew currentVersion >}}.
sudo systemctl enable --now kubelet ```shell
``` # Configure o SELinux em modo permissivo (efetivamente desabilitando-o)
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
**Avisos:** {{< caution >}}
- Configurar o SELinux em modo permissivo ao executar `setenforce 0` e `sed ...`
efetivamente o desabilita. Isso é necessário para permitir que os contêineres acessem o sistema de arquivos do hospedeiro; por exemplo, alguns plugins de rede de cluster requerem isso. Você deve
fazer isso até que o suporte ao SELinux seja melhorado no kubelet.
- Você pode manter o SELinux habilitado se souber como configurá-lo, mas pode ser necessário
configurações que não são suportadas pelo kubeadm.
{{< /caution >}}
- Colocar o SELinux em modo permissivo ao executar `setenforce 0` e `sed ...` efetivamente o desabilita. 2. Adicione o repositório `yum` do Kubernetes. O parâmetro `exclude` na
Isso é necessário para permitir que os contêineres acessem o sistema de arquivos do hospedeiro, que é utilizado pelas redes dos pods por exemplo. definição do repositório garante que os pacotes relacionados ao Kubernetes não
Você precisará disso até que o suporte ao SELinux seja melhorado no kubelet. sejam atualizados ao executar `yum update`, já que existe um procedimento especial que
deve ser seguido para atualizar o Kubernetes. Por favor, note que este repositório
tem pacotes apenas para o Kubernetes {{< skew currentVersion >}}; para outras
versões menores do Kubernetes, você precisa mudar a versão menor do Kubernetes
na URL para corresponder à sua versão menor desejada (você também deve verificar se
está lendo a documentação para a versão do Kubernetes que você planeja instalar).
- Você pode deixar o SELinux habilitado se você souber como configura-lo, mas isso pode exegir configurações que não são suportadas pelo kubeadm. ```shell
# Isso sobrescreve qualquer configuração existente em /etc/yum.repos.d/kubernetes.repo
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/{{< param "version" >}}/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/{{< param "version" >}}/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF
```
3. Instale o kubelet, kubeadm e kubectl:
```shell
sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
```
4. (Opcional) Habilite o serviço kubelet antes de executar kubeadm:
```shell
sudo systemctl enable --now kubelet
```
{{% /tab %}} {{% /tab %}}
{{% tab name="Sem um gerenciador de pacotes" %}} {{% tab name="Sem um gerenciador de pacotes" %}}
Instale os plugins CNI (utilizados por grande parte das redes de pods): Instale os plugins CNI (utilizados por grande parte das redes de Pods):
```bash ```bash
CNI_VERSION="v0.8.2" CNI_PLUGINS_VERSION="v1.3.0"
ARCH="amd64" ARCH="amd64"
sudo mkdir -p /opt/cni/bin DEST="/opt/cni/bin"
curl -L "https://github.com/containernetworking/plugins/releases/download/${CNI_VERSION}/cni-plugins-linux-${ARCH}-${CNI_VERSION}.tgz" | sudo tar -C /opt/cni/bin -xz sudo mkdir -p "$DEST"
curl -L "https://github.com/containernetworking/plugins/releases/download/${CNI_PLUGINS_VERSION}/cni-plugins-linux-${ARCH}-${CNI_PLUGINS_VERSION}.tgz" | sudo tar -C "$DEST" -xz
``` ```
Escolha o diretório para baixar os arquivos de comandos. Escolha o diretório para baixar os arquivos de comandos.
{{< note >}} {{< note >}}
A variável `DOWNLOAD_DIR` precisa estar configurada para um diretório que permita escrita. A variável `DOWNLOAD_DIR` deve ser definida para um diretório que permita escrita.
Se você estiver utilizando o Flatcar Container Linux, configure a váriavel de ambiente `DOWNLOAD_DIR=/opt/bin`. Se você está executando o Flatcar Container Linux, defina `DOWNLOAD_DIR="/opt/bin"`.
{{< /note >}} {{< /note >}}
```bash ```bash
DOWNLOAD_DIR=/usr/local/bin DOWNLOAD_DIR="/usr/local/bin"
sudo mkdir -p $DOWNLOAD_DIR sudo mkdir -p "$DOWNLOAD_DIR"
``` ```
Instale o crictl (utilizado pelo kubeadm e pela Interface do Agente de execução do Kubelet (CRI)) Instale o crictl (utilizado pelo kubeadm e pela Interface do Agente de execução do Kubelet (CRI))
```bash ```bash
CRICTL_VERSION="v1.22.0" CRICTL_VERSION="v1.28.0"
ARCH="amd64" ARCH="amd64"
curl -L "https://github.com/kubernetes-sigs/cri-tools/releases/download/${CRICTL_VERSION}/crictl-${CRICTL_VERSION}-linux-${ARCH}.tar.gz" | sudo tar -C $DOWNLOAD_DIR -xz curl -L "https://github.com/kubernetes-sigs/cri-tools/releases/download/${CRICTL_VERSION}/crictl-${CRICTL_VERSION}-linux-${ARCH}.tar.gz" | sudo tar -C $DOWNLOAD_DIR -xz
``` ```
Instale o `kubeadm`, o `kubelet`, e o `kubectl` e adicione o serviço systemd `kubelet`: Instale o `kubeadm`, o `kubelet`, e o `kubectl` e adicione um serviço systemd `kubelet`:
```bash ```bash
RELEASE="$(curl -sSL https://dl.k8s.io/release/stable.txt)" RELEASE="$(curl -sSL https://dl.k8s.io/release/stable.txt)"
ARCH="amd64" ARCH="amd64"
cd $DOWNLOAD_DIR cd $DOWNLOAD_DIR
sudo curl -L --remote-name-all https://dl.k8s.io/release/${RELEASE}/bin/linux/${ARCH}/{kubeadm,kubelet,kubectl} sudo curl -L --remote-name-all https://dl.k8s.io/release/${RELEASE}/bin/linux/${ARCH}/{kubeadm,kubelet}
sudo chmod +x {kubeadm,kubelet,kubectl} sudo chmod +x {kubeadm,kubelet}
RELEASE_VERSION="v0.4.0" RELEASE_VERSION="v0.16.2"
curl -sSL "https://raw.githubusercontent.com/kubernetes/release/${RELEASE_VERSION}/cmd/kubepkg/templates/latest/deb/kubelet/lib/systemd/system/kubelet.service" | sed "s:/usr/bin:${DOWNLOAD_DIR}:g" | sudo tee /etc/systemd/system/kubelet.service curl -sSL "https://raw.githubusercontent.com/kubernetes/release/${RELEASE_VERSION}/cmd/krel/templates/latest/kubelet/kubelet.service" | sed "s:/usr/bin:${DOWNLOAD_DIR}:g" | sudo tee /usr/lib/systemd/system/kubelet.service
sudo mkdir -p /etc/systemd/system/kubelet.service.d sudo mkdir -p /usr/lib/systemd/system/kubelet.service.d
curl -sSL "https://raw.githubusercontent.com/kubernetes/release/${RELEASE_VERSION}/cmd/kubepkg/templates/latest/deb/kubeadm/10-kubeadm.conf" | sed "s:/usr/bin:${DOWNLOAD_DIR}:g" | sudo tee /etc/systemd/system/kubelet.service.d/10-kubeadm.conf curl -sSL "https://raw.githubusercontent.com/kubernetes/release/${RELEASE_VERSION}/cmd/krel/templates/latest/kubeadm/10-kubeadm.conf" | sed "s:/usr/bin:${DOWNLOAD_DIR}:g" | sudo tee /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf
```
Habilite e inicie o `kubelet`:
```bash
systemctl enable --now kubelet
``` ```
{{< note >}} {{< note >}}
A distribuição Flatcar Container Linux instala o diretório `/usr` como um sistema de arquivos apenas para leitura. Por favor, consulte a nota na seção [Antes de começar](#before-you-begin) para distribuições Linux que não incluem `glibc` por padrão.
Antes de inicializar o seu cluster, você precisa de alguns passos adicionais para configurar um diretório com escrita. {{< /note >}}
Veja o [Guia de solução de problemas do Kubeadm](/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm/#usr-mounted-read-only/) para aprender como configurar um diretório com escrita.
Instale `kubectl` seguindo as instruções na [página de Instalação de Ferramentas](/docs/tasks/tools/#kubectl).
Opcionalmente, habilite o serviço kubelet antes de executar o kubeadm:
```bash
sudo systemctl enable --now kubelet
```
{{< note >}}
A distribuição Flatcar Container Linux monta o diretório `/usr` como um sistema de arquivos somente leitura.
Antes de iniciar seu cluster, você precisa tomar passos adicionais para configurar um diretório gravável.
Veja o [Guia de Solução de Problemas do Kubeadm](/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm/#usr-mounted-read-only)
para aprender como configurar um diretório gravável.
{{< /note >}} {{< /note >}}
{{% /tab %}} {{% /tab %}}
{{< /tabs >}} {{< /tabs >}}
O kubelet agora ficará reiniciando de alguns em alguns segundos, enquanto espera por instruções vindas do kubeadm. O kubelet agora ficará reiniciando de alguns em alguns segundos, enquanto espera por instruções vindas do kubeadm.
## Configurando um driver cgroup ## Configurando um driver cgroup