Programa de aprendizado: 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 conteinerizar um app monolítico.

O programa de aprendizado consiste nos seguintes tutoriais:

  1. Visão geral
  2. Entender o monolítico
  3. Modularizar o monolítico
  4. Preparar o app modular para conteinerização
  5. Conteinerizar o app modular
  6. Implantar o app em um cluster do GKE (este tutorial)

No tutorial anterior, Conteinerizar 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 de 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 Google Cloud conta. 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, conclua os tutoriais anteriores da série. Para uma visão geral de toda a série e links para tutoriais específicos, consulte Programa de aprendizado: transformar um monolítico em um app do GKE – visão geral.

Em especial, você precisa ter realizado as etapas do tutorial anterior, Conteinerizar o app modular.

Configurar o cluster do GKE

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

Neste tutorial, você usa a CLI gcloud para criar o cluster. Como alternativa, você pode usar o Google Cloud console, 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 contêineres no Kubernetes. Siga estas etapas para criar um cluster usando a CLI gcloud.

  1. Acesse o Google Cloud console.

  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 do Google Cloud.

  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. Um ID do projeto é uma string exclusiva que diferencia seu projeto de todos os outros projetos em Google Cloud. Para localizar o ID do projeto, acesse o seletor de projetos. Nessa página, você pode conferir os IDs de cada um dos seus Google Cloud projetos.

  4. Crie um cluster do GKE:

    gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --num-nodes=2

    Substitua:

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

    • CONTROL_PLANE_LOCATION: o local do Compute Engine do plano de controle do cluster. Forneça uma região para clusters regionais ou uma zona para clusters zonais, como us-central1 ou europe-west1-b.

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

    gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

    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 exige 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, informações sobre dois nós serão exibidas, semelhantes a estas:

    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 conteinerizado:

    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 conteinerizaçã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 encaminhe solicitações entre módulos e garante que os módulos 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 de API do Kubernetes que permite executar várias réplicas de pods distribuídos entre os nós em um cluster. A próxima seção explica o que são 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 de contêiner do Artifact Registry para o cluster. No cluster, as imagens de contêiner 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 funcionem.
  • Fornece rede: cada pod tem seu 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 de computação para o cluster. O Kubernetes atribui automaticamente pods a nós e os distribui entre os nós do cluster para reduzir o risco de sobrecarregar um único 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 corretamente no cluster. Para verificar a implantação, confira se os pods e serviços estão em execução 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 é 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 poderá não ter recursos suficientes para que o pod entre em um estado Running íntegro. Se um pod tiver o status CrashLoopBackOff, pode haver um problema com o contêiner. As etapas de solução de problemas sã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 conferir 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 serem observados na saída são os seguintes:

  • 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 está vazio porque os serviços ClusterIP só podem ser acessados no cluster.

Teste a implantação

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

Acessar o aplicativo

Confirme se o app está acessível seguindo estas etapas:

  1. Recupere 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 insira 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 de serviços para trocar informações. Siga estas etapas para garantir que os contêineres possam se comunicar de maneira eficaz:

  1. Recupere 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 seguintes recursos funcionam clicando em todos os links disponíveis na interface do app:

    • Verificar imagens de capa de livro: confirme se as imagens de capa de 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 estarão se comunicando corretamente com o contêiner images_app.
    • Conferir detalhes do livro: navegue até uma página de detalhes do livro na página inicial. Se você vir os detalhes de um livro, o contêiner home_app estará se comunicando corretamente com o book_details_app.
    • Conferir avaliações de livros: clique em um link de avaliação de livros para verificar se o home_app contêiner pode se comunicar com o book_reviews_app contêiner.

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 conteinerizado executado em um cluster do GKE ativo. Ao longo do caminho, você aprendeu a dividir o código fortemente acoplado em módulos independentes, criar e enviar imagens de contêiner para um repositório, definir manifestos do Kubernetes e implantar o app do registro no GKE. Essa é uma grande conquista e reflete as etapas reais que as equipes seguem para modernizar aplicativos para a nuvem.

Solução de problemas

Se o app não responder ou os contêineres não se comunicarem, siga as etapas de solução de problemas abaixo 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 conforme o esperado:

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 inspeção adicional.

Inspecionar registros de pods

Se um pod não estiver processando solicitações corretamente, verifique os registros dele 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 informações detalhadas

Se um pod permanecer em um estado não 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 que o pod seja iniciado corretamente.

Verificar as configurações de serviço

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

kubectl get services

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

kubectl describe service SERVICE_NAME

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

Esse comando fornece mais detalhes sobre as configurações de 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

Você pode 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 de recursos ou de rede mais amplos estão afetando sua implantação.

Limpar recursos

A execução de um cluster do GKE gera custos. Depois de concluir este tutorial, limpe os 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
    --location=CONTROL_PLANE_LOCATION

Substitua:

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

  • CONTROL_PLANE_LOCATION: o local do Compute Engine do plano de controle do cluster. Forneça uma região para clusters regionais ou uma zona para clusters zonais.

Quando solicitado, confirme a exclusão.

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 instantes e tente novamente.

(Opcional) Excluir o Google Cloud projeto

Se você criou um Google Cloud projeto especificamente para este tutorial e não precisa mais dele, é possível excluir todo o Google Cloud projeto. A exclusão do projeto remove todos os recursos e interrompe o faturamento do projeto:

  1. No Google Cloud console do, 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 aprendizado, você aprendeu os fundamentos da conversão de um app monolítico em um app modular e conteinerizado executado em um cluster do Kubernetes. As etapas a seguir resumem o processo:

  1. Entender o monolítico

    • Explorou a estrutura do app monolítico Cymbal Books.
    • Configurou um ambiente Python local para executar o monolítico e testou os endpoints dele.
    • Entendeu 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 exibir detalhes ou avaliações de livros.
    • Viu como esses módulos são implementados como apps Flask independentes executados em portas diferentes.
    • Testou o app modularizado.

  3. Preparar o código modular para conteinerização

    • Aprendeu que era necessário atualizar os URLs em home.py para usar nomes de serviço em vez de localhost.
    • Aprendeu como o manifesto do Kubernetes define os 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

    • Configurou um Google Cloud projeto e clonou o app do GitHub para o Cloud Shell.
    • Criou imagens de contêiner para cada módulo usando o Docker e testou contêineres localmente.
    • Enviou as imagens de contêiner para o Artifact Registry para preparar o app para implantação em um cluster.
    • Atualizou o manifesto do Kubernetes para se referir aos caminhos da imagem de contêiner no Artifact Registry.

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

    • Criou 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 treinamentos práticos sobre como criar clusters, consulte nossa série, Programa de aprendizado: aplicativos escalonáveis.