Pod

Nesta página, descrevemos o objeto pod do Kubernetes e o uso dele no Kubernetes Engine.

O que é um pod?

Pods são os menores e mais básicos objetos implantáveis no Kubernetes. Um pod representa uma única instância de um processo em execução no seu cluster.

Os pods contêm um ou mais contêineres, como os Docker. Quando um pod executa vários contêineres, eles são gerenciados como uma única entidade e compartilham os recursos do pod. Geralmente, executar vários contêineres em um único pod é um caso de uso avançado.

Os pods também contêm recursos compartilhados de rede e armazenamento para os contêineres:

  • Rede: endereços IP exclusivos são atribuídos automaticamente aos pods. Os contêineres do pod compartilham o mesmo namespace da rede, incluindo o endereço IP e as portas de rede. Os contêineres em um pod se comunicam entre si no localhost.
  • Armazenamento: os pods podem especificar um conjunto de volumes de armazenamento compartilhado que pode ser compartilhado entre os contêineres.

Pense em um pod como um "host lógico" autônomo e isolado que contém as necessidades sistêmicas do aplicativo que ele veicula.

Um pod destina-se a executar uma única instância do seu aplicativo em seu cluster. No entanto, não é recomendado criar pods individuais diretamente. Em vez disso, geralmente cria-se um conjunto de pods idênticos, chamado réplicas, para executar o aplicativo. Esse conjunto é criado e gerenciado por um controlador, como o de implantação. Os controladores gerenciam o ciclo de vida dos pods constituintes e também podem executar escalonamento horizontal, alterando o número de pods conforme necessário.

De vez em quanto, você pode interagir com pods de maneira direta para depurar, solucionar problemas ou inspecioná-los, mas é altamente recomendável usar um controlador para gerenciá-los.

Os pods são executados em nodes no cluster. Depois de criado, ele permanece no node até que o processo seja concluído, o pod seja excluído, removido do node por falta de recursos ou pela falha do node. Se um node falhar, os pods nele serão programados para exclusão automaticamente.

Ciclo de vida do pod

Os pods são efêmeros. Eles não são projetados para permanecer em execução para sempre e, depois de encerrados, não podem ser recuperados. Em geral, os pods não desaparecem até serem excluídos por um usuário ou por um controlador.

Os pods não se corrigem ou se reparam sozinhos. Por exemplo, se um pod for programado em um node e esse node falhar posteriormente, o pod será excluído. Da mesma forma, se um pod for removido de um node por qualquer motivo, ele não será substituído.

Cada pod tem um objeto de PodStatus API, que é representado pelo campo status. Os pods publicam a própria fase no campo status: phase. A fase é um resumo detalhado do estado atual do pod.

Ao executar kubectl get pod para inspecionar um pod em execução no cluster, ele pode estar em uma das seguintes fases:

  • Pendente: o pod foi criado e aceito pelo cluster, mas um ou mais contêineres ainda não estão em execução. Essa fase inclui o tempo gasto para a programação em um nó e o download de imagens.
  • Em execução: o pod foi vinculado a um nó, e todos os contêineres foram criados. Pelo menos um contêiner está em execução, no processo de iniciar ou está reiniciando.
  • Bem-sucedido: todos os contêineres no pod foram encerrados com sucesso. Os pods encerrados não são reiniciados.
  • Falha: todos os contêineres no pod foram encerrados e pelo menos um foi encerrado com falha. Um contêiner "falha" se ele é encerrado com um status diferente de zero.
  • Desconhecido: o estado do pod não pode ser determinado.

Além disso, o PodStatus contém uma matriz chamada PodConditions, que é representada no manifesto do pod como conditions. Há um campo type e status. conditions indica mais especificamente as condições dentro do pod que estão causando o status atual.

O campo type pode conter PodScheduled, Ready, Initialized e Unschedulable. O campo status corresponde ao type e pode conter True, False ou Unknown.

Crie pods

Como os pods são efêmeros, não é necessário criá-los diretamente. Da mesma forma, como os pods não podem reparar nem substituir a eles mesmos, não é recomendável criar pods diretamente.

Em vez disso, você pode usar um controlador, como o de implantação, para criar e gerenciar pods. Os controladores também são úteis para implementar atualizações, como a alteração da versão de um aplicativo executado em um contêiner, já que o controlador gerencia todo o processo de atualização para você.

Modelos de pod

Nos objetos do controlador, como implantações e StatefulSets, há um campo de modelo de pod. Os modelos têm uma especificação de pod que determina como cada um é executado. Isso inclui quais contêineres serão executados nos pods e quais volumes os pods ativarão.

Os objetos de controlador usam os modelos de pod para criar pods e gerenciar o "estado pretendido" dele dentro do cluster. Quando um modelo de pod é alterado, todos os pods futuros refletem o novo modelo, mas os pods existentes não.

Para ver mais informações sobre como os modelos de pod funcionam, consulte Como criar uma implantação na documentação do Kubernetes.

Como controlar em quais nós um pod é executado

Por padrão, os pods são executados nos nós no pool de nós padrão do cluster. É possível configurar o pool de nós que um pod seleciona de forma explícita ou implícita:

  • É possível forçar explicitamente um pod a implantar em um pool de nós específico configurando um nodeSelector no manifesto do pod. Isso força um pod a ser executado apenas nos nós desse pool.

  • É possível especificar as solicitações de recursos para os contêineres que você executa. O pod será executado apenas em nós que satisfaçam as solicitações de recursos. Por exemplo, se a definição do pod incluir um contêiner que requer quatro CPUs, o Serviço não selecionará pods em execução nos Nós com dois CPUs.

Padrões de uso de pod

Os pods podem ser usados de duas maneiras principais:

  • Pods que executam um único contêiner: o padrão mais simples e comum é um único contêiner por pod, em que esse contêiner representa um aplicativo completo. Nesse caso, pense em um pod como um invólucro.
  • Pods que executam vários contêineres que precisam trabalhar juntos: pods com vários contêineres são usados principalmente para dar suporte a programas colocalizados e cogerenciados que precisam compartilhar recursos. Esses contêineres colocalizados podem formar uma única unidade de serviço coesa: um contêiner que veicula arquivos de um volume compartilhado enquanto outro contêiner atualiza esses arquivos. O pod envolve contêineres e recursos de armazenamento juntos como uma única entidade gerenciável.

Cada pod executa uma única instância de um determinado aplicativo. Se quiser executar múltiplas instâncias, você deve usar um pod para cada instância do aplicativo. Isso geralmente é chamado de replicação. Os pods replicados são criados e gerenciados em grupo por um controlador, como o de implantação.

Encerramento de pods

Os pods são encerrados de maneira prática quando os processos são completos. Por padrão, todas as terminações ocorrem normalmente dentro de 30 segundos.

Para excluir manualmente um pod, use o comando kubectl delete. A sinalização --grace-period do comando permite que você modifique o período de carência padrão.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine