Objetivos
- Aprenda sobre Pods do Kubernetes.
- Aprenda sobre Nós do Kubernetes.
- Solucione problemas de aplicativos implantados no Kubernetes.
Kubernetes Pods
Quando você criou um Deployment no Módulo 2, o Kubernetes criou um Pod para hospedar a instância do seu aplicativo. Um Pod é uma abstração do Kubernetes que representa um grupo de um ou mais contêineres de aplicativos (como Docker) e alguns recursos compartilhados para esses contêineres. Esses recursos incluem:
- Armazenamento compartilhado, como Volumes
- Rede, como um endereço IP único no cluster
- Informações sobre como executar cada contêiner, como a versão da imagem do contêiner ou portas específicas a serem usadas
Um Pod define um "host lógico" específico para o aplicativo e pode conter diferentes contêineres de aplicativos que, na maioria dos casos, são fortemente acoplados. Por exemplo, um Pod pode incluir tanto o contêiner com seu aplicativo Node.js quanto um outro contêiner que alimenta os dados a serem publicados pelo servidor web do Node.js. Os contêineres de um Pod compartilham um endereço IP e intervalo de portas, são sempre co-localizados, co-alocados e executam em um contexto compartilhado no mesmo Nó.
Pods são a unidade atômica na plataforma Kubernetes. Quando criamos um Deployment no Kubernetes, esse Deployment cria Pods com contêineres dentro dele (em vez de você criar contêineres diretamente). Cada Pod está vinculado ao nó onde está alocado e lá permanece até o encerramento (de acordo com a política de reinicialização) ou exclusão. Em caso de falha do nó, Pods idênticos são alocados em outros nós disponíveis no cluster.
Sumário:
- Pods
- Nós
- Principais comandos do Kubectl
Um Pod é um grupo de um ou mais contêineres de aplicativos (como Docker) que inclui armazenamento compartilhado (volumes), endereço IP e informações sobre como executá-los.
Visão geral sobre os Pods
Nós
Um Pod sempre será executado em um Nó. Um Nó é uma máquina de processamento em um cluster Kubernetes e pode ser uma máquina física ou virtual. Cada Nó é gerenciado pela Camada de Gerenciamento. Um Nó pode possuir múltiplos Pods e a Camada de Gerenciamento do Kubernetes gerencia automaticamente a alocação dos Pods nos nós do cluster. A alocação automática dos Pods pela Camada de Gerenciamento leva em consideração os recursos disponíveis em cada Nó.
Cada Nó do Kubernetes executa pelo menos:
- O Kubelet, que é o processo responsável pela comunicação entre a Camada de Gerenciamento e o Nó; gerencia os Pods e os contêineres rodando em uma máquina.
- Um agente de execução de contêiner (por exemplo, Docker) responsável por baixar a imagem do contêiner de um registro de imagens (por exemplo, o Docker Hub), extrair o contêiner e executar a aplicação.
Os contêineres só devem ser alocados juntos em um único Pod se estiverem fortemente acoplados e precisarem compartilhar recursos, como disco, por exemplo.
Visão Geral sobre os Nós
Solucionando problemas usando o comando kubectl
No Módulo 2, você usou a ferramenta de linha de comando kubectl. Você irá continuar utilizando o kubectl no Módulo 3 para obter informação sobre aplicações implantadas e seus recursos. As operações mais comuns podem ser efetuadas com os comandos abaixo:
- kubectl get - listar recursos
- kubectl describe - mostrar informações detalhadas sobre um recurso
- kubectl logs - mostrar os logs de um contêiner em um Pod
- kubectl exec - executar um comando em um contêiner em um Pod
Você pode usar esses comandos para verificar quando o Deployment foi criado, qual seu status atual, onde os Pods estão rodando e quais são as suas configurações.
Agora que sabemos mais sobre os componentes de um cluster Kubernetes e o comando kubectl, vamos explorar a nossa aplicação.
Um nó é uma máquina de processamento do Kubernetes e pode ser uma VM ou máquina física, dependendo do cluster. Vários Pods podem ser executados em um nó.
Verifique a configuração da aplicação
Vamos verificar que a aplicação que implantamos no cenário anterior
está executando. Iremos utilizar o comando kubectl get
e procurar por Pods existentes:
kubectl get pods
Se nenhum Pod estiver rodando, aguarde alguns instantes e liste os Pods novamente. Você pode continuar assim que ver um Pod rodando.
A seguir, para visualizar quais contêineres encontram-se no Pod e quais
imagens foram utilizadas para criar tais contêineres iremos usar o
comando kubectl describe pods:
kubectl describe pods
Vemos aqui detalhes a respeito dos contêineres do Pod: endereço IP, portas utilizadas e uma lista de eventos relacionados ao ciclo de vida do Pod.
A saída do subcomando describe é extensa e cobre alguns conceitos que não foram explicados ainda. Não se preocupe, estes conceitos serão familiares até o fim deste bootcamp.
Nota: o subcomando describe pode ser utilizado para obter informações detalhadas sobre a maioria das primitivas do Kubernetes, incluindo Nós (Nodes), Pods e Deployments. A saída do subcomando describe é projetada para ser legível por humanos, não para ser consumida por processos automatizados.
Exiba a aplicação no terminal
Lembre-se que Pods estão executando em uma rede isolada e privada -
portanto, precisaremos de um proxy para acessá-los, a fim de tornar
possível a depuração e a interação com estes objetos. Para inicializar
um proxy, utilizaremos o comando kubectl proxy em um
segundo terminal. Abra uma nova janela do terminal,
e nesta nova janela, execute o comando:
kubectl proxy
Agora iremos novamente obter o nome do Pod e obter informações do Pod diretamente através do proxy. Para obter o nome do Pod e armazená-lo na variável de ambiente POD_NAME, utilize o comando:
export POD_NAME="$(kubectl get pods -o go-template --template
'{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}')"echo Nome do Pod: $POD_NAME
Para ver a saída da aplicação, execute uma requisição com o comando
curl:
curl http://localhost:8001/api/v1/namespaces/default/pods/$POD_NAME:8080/proxy/
A URL é a rota para a API do Pod.
Visualize os logs do contêiner
Qualquer mensagem que normalmente seria impressa na saída padrão (stdout)
torna-se parte do log do contêiner dentro do Pod. Podemos obter tais
logs utilizando o comando kubectl logs:
kubectl logs "$POD_NAME"
Nota: não é necessário especificarmos o nome do contêiner pois temos apenas um contêiner neste Pod.
Executando comandos no contêiner
Podemos executar comandos diretamente no contêiner uma vez que o
Pod esteja criado e rodando. Para isso, utilizaremos o subcomando
exec e o nome do Pod como um parâmetro. Vamos listar
as variáveis de ambiente:
kubectl exec "$POD_NAME" -- env
Novamente, vale a pena mencionar que o nome do contêiner pode ser omitido pois temos apenas um contêiner no Pod.
A seguir, vamos iniciar uma sessão do bash no contêiner do Pod:
kubectl exec -ti $POD_NAME -- bash
Agora temos um terminal aberto no contêiner onde nossa aplicação Node.js está executando. O código-fonte da aplicação encontra-se no arquivo server.js:
cat server.js
Você pode verificar que a aplicação está rodando utilizando uma requisição com o comando curl:
curl http://localhost:8080
Nota: aqui utilizamos localhost pois
executamos o comando dentro do Pod do Node.js. Se você não conseguir
conectar-se a localhost:8080, certifique-se de que você utilizou
o comando kubectl exec e que está rodando a requisição
curl de dentro do Pod.
Para encerrar sua conexão ao contêiner, digite exit.
Assim que você finalizar este tutorial, vá para Utilizando um Service para expor sua aplicação .