Programa de treinamentos: transformar um monólito em um app do GKE: implantar o app em um cluster do GKE

Este é o quinto e último tutorial de um programa de aprendizado que ensina como modularizar e contêinerizar um app monolítico.

O Programa de aprendizado consiste nos seguintes tutoriais:

  1. Visão geral
  2. Noções básicas sobre o monolítico
  3. Modularizar o monolítico
  4. Preparar o app modular para contêinerização
  5. Conteinerizar o app modular
  6. Implantar o app em um cluster do GKE (neste tutorial)

No tutorial anterior, Contenerizar o app modular, você preparou o app modular Cymbal Books para implantação. Você conteinerizou os módulos do app, testou os contêineres resultantes e enviou as imagens do contêiner para o Artifact Registry.

Neste tutorial, você vai implantar o app conteinerizado em um cluster do Google Kubernetes Engine. Esta etapa conclui a transformação do app Cymbal Books em um sistema modular e escalonável executado em um cluster do Kubernetes.

Custos

Seguir as etapas deste tutorial gera cobranças na sua conta Google Cloud. Os custos começam quando você ativa o GKE e implanta o app de exemplo Cymbal Books. Esses custos incluem cobranças por cluster do GKE, conforme descrito na página de preços, e cobranças pela execução de VMs do Compute Engine.

Para evitar cobranças desnecessárias, desative o GKE ou exclua o projeto depois de concluir este tutorial.

Antes de começar

Antes de começar este tutorial, confira se você concluiu os tutoriais anteriores da série. Para ter uma visão geral de toda a série e links para tutoriais específicos, consulte Programa de treinamentos: transformar um monólito em um app do GKE - visão geral.

Em particular, você precisa ter realizado as etapas no tutorial anterior, Contenerizar o app modular.

Configurar o cluster do GKE

Antes de implantar o app modular do Cymbal Books, é necessário criar um cluster do GKE. Esse cluster fornece a infraestrutura em que os contêineres do app serão executados.

Neste tutorial, você vai usar a CLI gcloud para criar o cluster. Como alternativa, use o consoleGoogle Cloud , que fornece uma interface gráfica do usuário (GUI) para criar e gerenciar Google Cloud recursos, como clusters do GKE.

Criar e verificar um cluster do GKE

Um cluster do GKE fornece os recursos de computação necessários para executar seus contêineres no Kubernetes. Siga estas etapas para criar um cluster usando a CLI do gcloud.

  1. Acesse o console doGoogle Cloud .

  2. No console, clique no botão Ativar o Cloud Shell: Ativar o Cloud Shell

    Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console.

  3. Defina o projeto padrão na Google Cloud CLI:

    gcloud config set project PROJECT_ID

    Substitua PROJECT_ID pelo ID do projeto que você criou ou selecionou na seção selecionar ou criar um Google Cloud projeto do tutorial anterior. O ID do projeto é uma string exclusiva que diferencia seu projeto de todos os outros em Google Cloud. Para encontrar o ID do projeto, acesse o seletor de projetos. Nessa página, você pode conferir os IDs de cada um dos seus projetos Google Cloud.

  4. Crie um cluster do GKE:

    gcloud container clusters create CLUSTER_NAME \
    --zone=ZONE \
    --num-nodes=2

    Substitua:

    • CLUSTER_NAME: um nome para o cluster, como cymbal-cluster.

    • ZONE: a zona em que você quer que o cluster seja criado, como us-central1-a ou europe-west1-b. Para uma lista completa de zonas disponíveis, consulte Regiões e zonas.

  5. Recupere as credenciais do cluster para que a CLI kubectl possa se conectar a ele:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=ZONE

    Esse comando atualiza o arquivo de configuração do Kubernetes, que é armazenado por padrão em ~/.kube/config. Esse arquivo de configuração contém as credenciais que kubectl precisa para interagir com o cluster do GKE.

  6. Verifique se kubectl está conectado ao cluster listando os nós do cluster:

    kubectl get nodes

    Se a configuração for bem-sucedida, esse comando vai listar os nós no cluster do GKE. Como você criou o cluster com --num-nodes=2, vai aparecer informações sobre dois nós, semelhantes a esta:

    NAME                                         STATUS    ROLES    AGE    VERSION
gke-nov18-default-pool-6a8f9caf-bryg   Ready     <none>   30s    v1.30.8-gke.1128000
gke-nov18-default-pool-6a8f9caf-ut0i   Ready     <none>   30s    v1.30.8-gke.1128000

    Neste exemplo, os dois nós estão no estado Ready. Esse estado significa que o cluster do GKE está pronto para hospedar suas cargas de trabalho conteinerizadas.

Implantar o aplicativo

Agora que você criou um cluster do GKE, é possível implantar o app Cymbal Books nele. Para implantar um app em um cluster, aplique o manifesto do Kubernetes ao cluster.

Aplicar o manifesto do Kubernetes

No Cloud Shell, implante o app no cluster do GKE executando os seguintes comandos:

  1. Navegue até o diretório raiz do aplicativo contêinerizado:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Aplique o manifesto do Kubernetes:

    kubectl apply -f kubernetes_manifest.yaml

O comando anterior instrui o Kubernetes a criar os recursos especificados no arquivo kubernetes-manifest.yaml. Esses recursos incluem serviços, uma implantação e pods.

Você encontrou os serviços pela primeira vez na seção Mudar o código modular do tutorial Preparar o app modular para contêinerização. Nesse tutorial, você atualizou o código do app para usar nomes de serviço em vez de localhost. Essa atualização permite que o Kubernetes roteie solicitações entre módulos e garante que eles possam se comunicar entre si em um cluster. Agora, quando você aplica o manifesto, o Kubernetes cria os serviços dentro do cluster.

Uma implantação é um objeto da API do Kubernetes que permite executar várias réplicas de pods distribuídos entre os nós de um cluster. A próxima seção explica o que são os pods.

O que é um pod do Kubernetes?

No tutorial anterior, você criou uma imagem de contêiner para cada módulo do app Cymbal Books. Por exemplo, você criou imagens de contêiner com base nos módulos home_app e book_details_app.

Quando você usa o comando kubectl apply para implantar o manifesto do Kubernetes, o Kubernetes extrai as imagens do contêiner do Artifact Registry para o cluster. No cluster, as imagens de contêineres se tornam contêineres, e os contêineres são executados dentro de pods.

Um pod é um ambiente isolado em que os contêineres são executados e realiza as seguintes tarefas:

  • Aloca CPU e memória: um pod fornece os recursos necessários para que os contêineres operem.
  • Oferece rede: cada pod tem o próprio endereço IP. Isso permite que o pod se comunique com outros pods.

Os pods são executados em nós, que são as máquinas que fornecem poder computacional para o cluster. O Kubernetes atribui pods aos nós automaticamente e os distribui entre os nós do cluster para reduzir o risco de sobrecarga de qualquer nó. Essa distribuição ajuda o cluster a usar os recursos de computação e memória de maneira eficiente.

Verificar a implantação

Depois de aplicar o manifesto do Kubernetes com o comando kubectl apply, verifique se o app foi implantado no cluster. Para verificar a implantação, verifique se os pods e serviços estão sendo executados corretamente.

Verificar os pods

Para conferir os pods no cluster, execute o seguinte comando:

kubectl get pods

Esse comando lista os pods e o status atual deles. Procure a coluna STATUS para confirmar se todos os pods estão marcados como Running, o que indica que eles estão em execução e prontos para atender solicitações. A saída esperada será semelhante a esta:

NAME                             READY   STATUS    RESTARTS   AGE
home-app-67d59c6b6d-abcde        1/1     Running   0          30s
book-details-app-6d8bcbc58f-xyz  1/1     Running   0          30s
book-reviews-app-75db4c4d7f-def  1/1     Running   0          30s
images-app-7f8c75c79c-ghi        1/1     Running   0          30s

O status de um pod aparece inicialmente como Pending enquanto ele está sendo criado e os contêineres estão em processo de inicialização. Se um pod permanecer Pending por um período prolongado, o cluster pode não ter recursos suficientes para que esse pod entre em um estado Running saudável. Se um pod tiver o status CrashLoopBackOff, pode haver um problema com o contêiner. As etapas de solução de problemas serão fornecidas mais adiante no tutorial.

Verificar os serviços

Os serviços permitem a comunicação entre pods e permitem que clientes externos (por exemplo, usuários, scripts automatizados ou ferramentas de monitoramento) acessem o app. Para visualizar os serviços no cluster, execute o seguinte comando:

kubectl get services

A saída desse comando é semelhante a esta:

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
home-app-service   LoadBalancer   10.12.3.4       35.185.1.2        80:30837/TCP   30s
details-service    ClusterIP      10.12.3.5       <none>            80/TCP         30s
reviews-service    ClusterIP      10.12.3.6       <none>            80/TCP         30s
images-service     LoadBalancer   10.12.3.7       34.125.6.3        80:32014/TCP   30s

Os principais campos a observar na saída são:

  • TYPE: esse campo indica como o serviço é exposto. Os serviços do tipo LoadBalancer fornecem acesso externo ao app.
  • EXTERNAL-IP: para um serviço do tipo LoadBalancer, o campo EXTERNAL-IP mostra o endereço IP público que os usuários podem inserir no navegador da Web para acessar o app. Para um serviço do tipo ClusterIP, esse campo fica vazio porque os serviços ClusterIP só são acessíveis dentro do cluster.

Teste a implantação

Depois de implantar o app Cymbal Books no cluster do GKE, verifique se ele está acessível e se os contêineres podem se comunicar entre si.

Acessar o aplicativo

Siga estas etapas para confirmar se o app é acessível:

  1. Extraia o endereço IP externo do home-app-service:

    kubectl get services

    Procure a coluna **EXTERNAL-IP** na saída e anote o endereço IP associado a home-app-service.

  2. Abra um navegador da Web e digite o seguinte URL:

    http://EXTERNAL-IP

    Substitua EXTERNAL-IP pelo endereço IP encontrado na etapa anterior.

  3. Verifique se a página inicial do app Cymbal Books é carregada corretamente.

Verificar a comunicação entre serviços

Os contêineres no app Cymbal Books dependem dos serviços para trocar informações. Para garantir que os contêineres possam se comunicar de forma eficaz, siga estas etapas:

  1. Extraia o endereço IP externo do home-app-service, conforme descrito anteriormente.

  2. Use a interface do app para testar interações entre contêineres. Para fazer isso, confirme se os recursos a seguir funcionam clicando em todos os links disponíveis na interface do app:

    • Verificar as imagens da capa do livro: confirme se as imagens da capa do livro são carregadas corretamente na página inicial e na página de detalhes do livro. Se isso acontecer, os contêineres home_app e book_details_app vão se comunicar com o contêiner images_app.
    • Conferir os detalhes do livro: acesse uma página de detalhes do livro na página inicial. Se os detalhes de um livro aparecerem, o contêiner home_app vai se comunicar corretamente com o book_details_app.
    • Conferir as avaliações de livros: clique em um link de avaliação de livro para verificar se o contêiner home_app pode se comunicar com o book_reviews_app.

Agora seu app está sendo executado em um cluster do GKE.

Parabéns! Você aprendeu a transformar um app monolítico em um sistema modular e contêinerizado que é executado em um cluster ativo do GKE. No caminho, você aprendeu a dividir o código acoplado em módulos independentes, criar e enviar imagens de contêineres para um repositório, definir manifestos do Kubernetes e implantar seu app do registro para o GKE. Essa é uma grande conquista, e reflete as etapas reais que as equipes precisam seguir para modernizar aplicativos para a nuvem.

Solução de problemas

Se o app não responder ou os contêineres não conseguirem se comunicar, use as etapas de solução de problemas a seguir para diagnosticar e resolver problemas comuns.

Verificar o status dos pods

Comece listando todos os pods no cluster para determinar se eles estão sendo executados corretamente:

kubectl get pods

Analise a saída para confirmar se cada pod está no estado Running. Se algum pod não estiver em execução, anote o nome dele para uma inspeção mais detalhada.

Inspecionar registros do pod

Se um pod não estiver processando as solicitações corretamente, verifique os registros para procurar mensagens de erro:

kubectl logs POD_NAME

Substitua POD_NAME pelo nome do pod que você quer inspecionar. Esse comando é útil para identificar problemas de inicialização ou erros de execução.

Descrever um pod para conferir informações detalhadas

Se um pod permanecer em um estado diferente de Running por mais de cinco minutos, por exemplo, em um estado Pending, ContainerCreating ou CrashLoopBackOff, você poderá conferir informações detalhadas sobre o status e os eventos do pod usando o seguinte comando:

kubectl describe pod POD_NAME

Substitua POD_NAME pelo nome do pod sobre o qual você quer informações detalhadas.

A seção Events na saída pode indicar que restrições de recursos ou problemas com extrações de imagem estão impedindo a inicialização adequada do pod.

Verificar a configuração do serviço

Verifique se os serviços estão configurados corretamente, principalmente o serviço que expõe o módulo de casa com um endereço IP externo. Liste os serviços com o seguinte comando:

kubectl get services

Se você notar que o módulo do serviço para a casa tem um endereço EXTERNAL-IP listado como Pending, execute o comando a seguir:

kubectl describe service SERVICE_NAME

Substitua SERVICE_NAME pelo nome do serviço do módulo inicial.

Esse comando fornece mais detalhes sobre a configuração do serviço e ajuda a identificar atrasos na atribuição do endereço IP externo ou outros problemas de configuração.

Verificar eventos do cluster

É possível examinar os eventos do cluster para determinar se um problema está afetando vários componentes do cluster:

kubectl get events

Esse comando pode determinar se problemas mais amplos de recursos ou de rede estão afetando a implantação.

Limpar recursos

A execução de um cluster do GKE gera custos. Depois de concluir este tutorial, limpe seus recursos para evitar cobranças adicionais. Siga estas etapas para remover o cluster e, opcionalmente, todo o projeto.

Excluir o cluster do GKE

Para excluir o cluster do GKE, use o seguinte comando:

gcloud container clusters delete CLUSTER_NAME
    --zone=ZONE

Substitua:

  • CLUSTER_NAME: o nome do cluster que você criou, como cymbal-cluster.

  • ZONE: a zona em que o cluster foi criado, como us-central1-a.

Confirme a exclusão quando solicitado.

Verificar se o cluster foi excluído

Para garantir que o cluster foi excluído, execute o seguinte comando:

gcloud container clusters list

O cluster não vai mais aparecer na saída. Se isso acontecer, aguarde alguns momentos e tente novamente.

(Opcional) Excluir o Google Cloud projeto

Se você criou um projeto Google Cloud específico para este tutorial e não precisa mais dele, exclua o projeto Google Cloud inteiro. A exclusão do projeto remove todos os recursos e interrompe o faturamento dele:

  1. No Google Cloud console, abra a página Gerenciar recursos.
  2. Selecione o projeto que você quer excluir.
  3. Clique em Excluir projeto e siga as instruções para confirmar.

Resumo da série

Parabéns! Ao concluir este programa de treinamento, você aprendeu os conceitos básicos de conversão de um app monolítico em um app modular e contêinerizado que é executado em um cluster do Kubernetes. As etapas a seguir resumem o processo:

  1. Noções básicas sobre o monolítico

    • Conhecer a estrutura do app monolítico do Cymbal Books.
    • Configure um ambiente local do Python para executar o monolito e teste os endpoints.
    • Entender a base de código do app para prepará-lo para a modularização.

  2. Modularizar o monolítico

    • Aprendeu a dividir o código monolítico em módulos separados. Cada módulo processa um recurso distinto, como mostrar detalhes ou avaliações de livros.
    • Vimos como esses módulos são implementados como apps Flask independentes em execução em portas diferentes.
    • Testou o app modularizado.

  3. Preparar o código modular para contêinerização

    • Você aprendeu que precisa atualizar os URLs em home.py para usar nomes de serviço em vez de localhost.
    • Aprendeu como o manifesto do Kubernetes define serviços que permitem que os módulos do app, que já se comunicam entre si, se encontrem no contexto de um cluster do Kubernetes.

  4. Conteinerizar o app modular

    • Configure um projeto Google Cloud e clone o app do GitHub no Cloud Shell.
    • Crie imagens de contêiner para cada módulo usando o Docker e teste os contêineres localmente.
    • Enviou as imagens do contêiner para o Artifact Registry para preparar o app para a implantação em um cluster.
    • Atualizamos o manifesto do Kubernetes para se referir aos caminhos de imagem do contêiner no Artifact Registry.

  5. Implante o app em um cluster do GKE (o tutorial em que você está agora):

    • Crie um cluster do GKE.
    • Implantou as imagens de contêiner do Artifact Registry no cluster do GKE.
    • Testou a versão final do app, que agora é escalonável e é executada em um ambiente do Kubernetes.

A seguir

Para mais treinamento prático sobre como criar clusters, consulte nossa série Programa de aprendizado: aplicativos escalonáveis.