This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

Instalação

Essa seção lista as diferentes formas de instalar e executar o Kubernetes. Quando você realiza a instalação de um cluster Kubernetes, deve decidir o tipo de instalação baseado em critérios como facilidade de manutenção, segurança, controle, quantidade de recursos disponíveis e a experiência necessária para gerenciar e operar o cluster.

Você pode criar um cluster Kubernetes em uma máquina local, na nuvem, em um datacenter on-premises ou ainda escolher uma oferta de um cluster Kubernetes gerenciado pelo seu provedor de computação em nuvem.

Existem ainda diversos outros tipos de soluções customizadas, que você pode se deparar ao buscar formas de instalação e gerenciamento de seu cluster.

Ambientes de aprendizado

Se você está aprendendo ou pretende aprender mais sobre o Kubernetes, use ferramentas suportadas pela comunidade, ou ferramentas no ecossistema que te permitam criar um cluster Kubernetes em sua máquina virtual.

Temos como exemplo aqui o Minikube e o KinD

Ambientes de produção

Ao analisar uma solução para um ambiente de produção, devem ser considerados quais aspectos de operação de um cluster Kubernetes você deseja gerenciar, ou então delegar ao seu provedor.

Temos diversas opções para esse provisionamento, desde o uso de uma ferramenta de deployment de um cluster tal qual o Kubeadm ou o Kubespray quando se trata de um cluster local, ou ainda o uso de um cluster gerenciado por seu provedor de nuvem.

Para a escolha do melhor ambiente e da melhor forma para fazer essa instalação, você deve considerar:

  • Se você deseja se preocupar com a gestão de backup da sua estrutura do ambiente de gerenciamento
  • Se você deseja ter um cluster mais atualizado, com novas funcionalidades, ou se deseja seguir a versão suportada pelo fornecedor
  • Se você deseja ter um cluster com um alto nível de serviço, ou com auto provisionamento de alta disponibilidade
  • Quanto você deseja pagar por essa produção

1 - Instalando a ferramenta kubeadm

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.

This installation guide is for Kubernetes v1.32. If you want to use a different Kubernetes version, please refer to the following pages instead:

Antes de você começar

  • Uma máquina com sistema operacional Linux compatível. O projeto Kubernetes provê instruções para distribuições Linux baseadas em Debian e Red Hat, bem como para distribuições sem um gerenciador de pacotes.
  • 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.
  • Conexão de rede entre todas as máquinas no cluster. Seja essa pública ou privada.
  • Nome de host único, endereço MAC e product_uuid para cada nó. Veja aqui para mais detalhes.
  • Certas portas estão abertas em suas máquinas. Veja aqui para mais detalhes.
  • 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.

Verifique se o endereço MAC e o product_uuid são únicos para cada nó

  • 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.

É 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.

Verificando os adaptadores de rede

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.

Verifique as portas necessárias

Essas portas necessárias precisam estar abertas para que os componentes do Kubernetes se comuniquem entre si. Você pode usar ferramentas como netcat para verificar se uma porta está aberta. Por exemplo:

nc 127.0.0.1 6443 -v

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.

Instalando um runtime de contêiner

Para executar contêiners em Pods, o Kubernetes usa um runtime de container.

Por padrão, o Kubernetes usa a Interface de Runtime de Container (CRI) para se comunicar com o runtime de contêiner escolhido.

Se você não especificar um runtime, o kubeadm tentará detectar automaticamente um runtime de contêiner instalado varrendo uma lista de endpoints conhecidos.

Se múltiplos ou nenhum runtime de contêiner forem detectados, o kubeadm lançará um erro e solicitará que você especifique qual deles deseja usar.

Veja runtimes de container para mais informações.

As tabelas abaixo incluem os endpoints conhecidos para sistemas operacionais suportados:

Runtimes de contêiner para Linux
Agente de execução Caminho para o socket de domínio Unix
containerd unix:///var/run/containerd/containerd.sock
CRI-O unix:///var/run/crio/crio.sock
Docker Engine (usando cri-dockerd) unix:///var/run/cri-dockerd.sock

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

Instalando o kubeadm, kubelet e o kubectl

Você instalará esses pacotes em todas as suas máquinas:

  • kubeadm: o comando para iniciar o cluster.

  • kubelet: o componente que executa em todas as máquinas do seu cluster e faz coisas como iniciar Pods e contêiners.

  • 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ê precisará garantir que eles correspondam à versão da camada de gerenciamento do Kubernetes 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 camada de gerenciamento é suportada, mas a versão do kubelet nunca poderá ser superior à versão do servidor da API. 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.

Para mais detalhes sobre compatibilidade entre as versões, veja:

Essas instruções são para o Kubernetes v1.32.

  1. Atualize o índice de pacotes apt e instale os pacotes necessários para usar o repositório apt do Kubernetes:

    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

  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:

    # 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:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

  1. Adicione o repositório apt apropriado do Kubernetes. Por favor, note que este repositório tem pacotes apenas para o Kubernetes 1.32; 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).

    # 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:/v1.32/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

  2. Atualize o índice de pacotes apt, instale o kubelet, o kubeadm e o kubectl, e fixe suas versões:

    sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

  3. (Opcional) Habilite o serviço kubelet antes de executar o kubeadm:

    sudo systemctl enable --now kubelet

  1. Configure o SELinux em modo permissivo:

    Essas instruções são para o Kubernetes 1.32.

    # Configure o SELinux em modo permissivo (efetivamente desabilitando-o)
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

  1. Adicione o repositório yum do Kubernetes. O parâmetro exclude na definição do repositório garante que os pacotes relacionados ao Kubernetes não 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 1.32; 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).

    # 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:/v1.32/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.32/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF

  2. Instale o kubelet, kubeadm e kubectl:

    sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

  3. (Opcional) Habilite o serviço kubelet antes de executar kubeadm:

    sudo systemctl enable --now kubelet

Instale os plugins CNI (utilizados por grande parte das redes de Pods):

CNI_PLUGINS_VERSION="v1.3.0"
ARCH="amd64"
DEST="/opt/cni/bin"
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.

DOWNLOAD_DIR="/usr/local/bin"
sudo mkdir -p "$DOWNLOAD_DIR"

Instale o crictl (utilizado pelo kubeadm e pela Interface do Agente de execução do Kubelet (CRI))

CRICTL_VERSION="v1.30.0"
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

Instale o kubeadm, o kubelet, e o kubectl e adicione um serviço systemd kubelet:

RELEASE="$(curl -sSL https://dl.k8s.io/release/stable.txt)"
ARCH="amd64"
cd $DOWNLOAD_DIR
sudo curl -L --remote-name-all https://dl.k8s.io/release/${RELEASE}/bin/linux/${ARCH}/{kubeadm,kubelet}
sudo chmod +x {kubeadm,kubelet}

RELEASE_VERSION="v0.16.2"
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 /usr/lib/systemd/system/kubelet.service.d
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

Instale kubectl seguindo as instruções na página de Instalação de Ferramentas.

Opcionalmente, habilite o serviço kubelet antes de executar o kubeadm:

sudo systemctl enable --now kubelet

O kubelet agora ficará reiniciando de alguns em alguns segundos, enquanto espera por instruções vindas do kubeadm.

Configurando um driver cgroup

Tanto o agente de execução quanto o kubelet possuem uma propriedade chamada "driver cgroup", que é importante para o gerenciamento dos cgroups em máquinas Linux.

Solucionando problemas

Se você encontrar problemas com o kubeadm, por favor consulte a nossa documentação de solução de problemas.

Próximos passos

2 - Instalando Kubernetes com kOps

Este início rápido mostra como instalar facilmente um cluster Kubernetes na AWS usando uma ferramenta chamada kOps.

kOps é um sistema de provisionamento automatizado:

Antes de você começar

Como criar um cluster

(1/5) Instalar kops

Instalação

Faça o download do kops na página de downloads (também é conveniente gerar um binário a partir do código-fonte):

Baixe a versão mais recente com o comando:

curl -LO https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-darwin-amd64

Para baixar uma versão específica, substitua a seguinte parte do comando pela versão específica do kops.

$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)

Por exemplo, para baixar kops versão v1.20.0 digite:

curl -LO https://github.com/kubernetes/kops/releases/download/v1.20.0/kops-darwin-amd64

Dê a permissão de execução ao binário do kops.

chmod +x kops-darwin-amd64

Mova o binário do kops para o seu PATH.

sudo mv kops-darwin-amd64 /usr/local/bin/kops

Você também pode instalar kops usando Homebrew.

brew update && brew install kops

Baixe a versão mais recente com o comando:

curl -LO https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64

Para baixar uma versão específica do kops, substitua a seguinte parte do comando pela versão específica do kops.

$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)

Por exemplo, para baixar kops versão v1.20.0 digite:

curl -LO https://github.com/kubernetes/kops/releases/download/v1.20.0/kops-linux-amd64

Dê a permissão de execução ao binário do kops

chmod +x kops-linux-amd64

Mova o binário do kops para o seu PATH.

sudo mv kops-linux-amd64 /usr/local/bin/kops

Você também pode instalar kops usando Homebrew.

brew update && brew install kops

(2/5) Crie um domínio route53 para seu cluster

O kops usa DNS para descoberta, tanto dentro do cluster quanto fora, para que você possa acessar o servidor da API do kubernetes a partir dos clientes.

kops tem uma opinião forte sobre o nome do cluster: deve ser um nome DNS válido. Ao fazer isso, você não confundirá mais seus clusters, poderá compartilhar clusters com seus colegas de forma inequívoca e alcançá-los sem ter de lembrar de um endereço IP.

Você pode e provavelmente deve usar subdomínios para dividir seus clusters. Como nosso exemplo usaremos useast1.dev.example.com. O endpoint do servidor de API será então api.useast1.dev.example.com.

Uma zona hospedada do Route53 pode servir subdomínios. Sua zona hospedada pode ser useast1.dev.example.com, mas também dev.example.com ou até example.com. kops funciona com qualquer um deles, então normalmente você escolhe por motivos de organização (por exemplo, você tem permissão para criar registros em dev.example.com, mas não em example.com).

Vamos supor que você esteja usando dev.example.com como sua zona hospedada. Você cria essa zona hospedada usando o processo normal, ou com um comando como aws route53 create-hosted-zone --name dev.example.com --caller-reference 1.

Você deve então configurar seus registros NS no domínio principal, para que os registros no domínio sejam resolvidos. Aqui, você criaria registros NS no example.com para dev. Se for um nome de domínio raiz, você configuraria os registros NS em seu registrador de domínio (por exemplo example.com, precisaria ser configurado onde você comprou example.com).

Verifique a configuração do seu domínio route53 (é a causa número 1 de problemas!). Você pode verificar novamente se seu cluster está configurado corretamente se tiver a ferramenta dig executando:

dig NS dev.example.com

Você deve ver os 4 registros NS que o Route53 atribuiu à sua zona hospedada.

(3/5) Crie um bucket do S3 para armazenar o estado dos clusters

O kops permite que você gerencie seus clusters mesmo após a instalação. Para fazer isso, ele deve acompanhar os clusters que você criou, juntamente com suas configurações, as chaves que estão usando etc. Essas informações são armazenadas em um bucket do S3. As permissões do S3 são usadas para controlar o acesso ao bucket.

Vários clusters podem usar o mesmo bucket do S3 e você pode compartilhar um bucket do S3 entre seus colegas que administram os mesmos clusters - isso é muito mais fácil do que transmitir arquivos kubecfg. Mas qualquer pessoa com acesso ao bucket do S3 terá acesso administrativo a todos os seus clusters, portanto, você não deseja compartilhá-lo além da equipe de operações.

Portanto, normalmente você tem um bucket do S3 para cada equipe de operações (e geralmente o nome corresponderá ao nome da zona hospedada acima!)

Em nosso exemplo, escolhemos dev.example.com como nossa zona hospedada, então vamos escolher clusters.dev.example.com como o nome do bucket do S3.

  • Exporte AWS_PROFILE (se precisar selecione um perfil para que a AWS CLI funcione)

  • Crie o bucket do S3 usando aws s3 mb s3://clusters.dev.example.com

  • Você pode rodar export KOPS_STATE_STORE=s3://clusters.dev.example.com e, em seguida, o kops usará esse local por padrão. Sugerimos colocar isso em seu perfil bash ou similar.

(4/5) Crie sua configuração de cluster

Execute kops create cluster para criar sua configuração de cluster:

kops create cluster --zones=us-east-1c useast1.dev.example.com

kops criará a configuração para seu cluster. Observe que ele apenas cria a configuração, na verdade não cria os recursos de nuvem - você fará isso na próxima etapa com um arquivo kops update cluster. Isso lhe dá a oportunidade de revisar a configuração ou alterá-la.

Ele exibe comandos que você pode usar para explorar mais:

  • Liste seus clusters com: kops get cluster
  • Edite este cluster com: kops edit cluster useast1.dev.example.com
  • Edite seu grupo de instâncias de nós: kops edit ig --name=useast1.dev.example.com nodes
  • Edite seu grupo de instâncias principal: kops edit ig --name=useast1.dev.example.com master-us-east-1c

Se esta é sua primeira vez usando kops, gaste alguns minutos para experimentá-los! Um grupo de instâncias é um conjunto de instâncias que serão registradas como nós do kubernetes. Na AWS, isso é implementado por meio de grupos de auto-scaling. Você pode ter vários grupos de instâncias, por exemplo, se quiser nós que sejam uma combinação de instâncias spot e sob demanda ou instâncias de GPU e não GPU.

(5/5) Crie o cluster na AWS

Execute kops update cluster para criar seu cluster na AWS:

kops update cluster useast1.dev.example.com --yes

Isso leva alguns segundos para ser executado, mas seu cluster provavelmente levará alguns minutos para estar realmente pronto. kops update cluster será a ferramenta que você usará sempre que alterar a configuração do seu cluster; ele aplica as alterações que você fez na configuração ao seu cluster - reconfigurando AWS ou kubernetes conforme necessário.

Por exemplo, depois de você executar kops edit ig nodes, em seguida execute kops update cluster --yes para aplicar sua configuração e, às vezes, você também precisará kops rolling-update cluster para implementar a configuração imediatamente.

Sem --yes, kops update cluster mostrará uma prévia do que ele fará. Isso é útil para clusters de produção!

Explore outros complementos

Consulte a lista de complementos para explorar outros complementos, incluindo ferramentas para registro, monitoramento, política de rede, visualização e controle de seu cluster Kubernetes.

Limpeza

  • Para excluir seu cluster: kops delete cluster useast1.dev.example.com --yes

Próximos passos

3 - Soluções de Nuvem Prontas para uso

Essa página fornece uma lista de provedores de soluções certificadas do Kubernetes. Na página de cada provedor, você pode aprender como instalar e configurar clusters prontos para produção.