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 a modularizar e contentorizar 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 contêinerização
  5. Conteinerizar o app modular
  6. Implantar o app em um cluster do GKE (este tutorial)

No tutorial anterior, Containerizar 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 que é executado em um cluster do Kubernetes.

Custos

Seguir as etapas deste tutorial gera cobranças na sua conta do 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, verifique se você concluiu 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 monólito em um app do GKE – Visão geral.

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

Configurar o cluster do GKE

Antes de implantar o app modular Cymbal Books, é preciso 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 Google Cloud console, que oferece uma interface gráfica do usuário (GUI) para criar e gerenciar recursos do Google Cloud, 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 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 seu 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 projeto do Google Cloud do tutorial anterior. O ID do projeto é uma string exclusiva que diferencia seu projeto de todos os outros em Google Cloud. Para localizar o ID do projeto, acesse o seletor de projetos. Nessa página, você pode ver os IDs de cada um dos seus projetos do Google Cloud.

  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. Informe 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 necessárias para que o kubectl interaja com seu cluster do GKE.

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

    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, as informações sobre dois nós vão aparecer, 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 em contêineres.

Implantar o aplicativo

Agora que você criou um cluster do GKE, pode 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 em contêiner:

    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ê conheceu os serviços 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 encaminhe 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 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 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 do 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 a operação dos contêineres.
  • 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 capacidade 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 no cluster. Para verificar a implantação, confira se os pods e serviços estão sendo executados corretamente.

Verificar os pods

Para ver 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 às solicitações. A saída esperada será assim:

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 ele 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 o acesso ao app por clientes externos (por exemplo, usuários, scripts automatizados ou ferramentas de monitoramento). Para conferir os serviços no cluster, execute o seguinte comando:

kubectl get services

A saída deste comando é semelhante a:

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: este 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ó 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

Siga estas etapas para confirmar se o app pode ser acessado:

  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 digite o seguinte URL:

    http://EXTERNAL-IP

    Substitua EXTERNAL-IP pelo endereço IP que você encontrou 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. 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 isso, clique em todos os links disponíveis na interface do app e confirme se os seguintes recursos funcionam:

    • Verifique as imagens da capa do livro: confirme se elas carregam corretamente na página inicial e na página de detalhes do livro. Se sim, os contêineres home_app e book_details_app estão se comunicando com o contêiner images_app.
    • Ver detalhes do livro: acesse a página de detalhes de um livro na página inicial. Se você vir os detalhes de um livro, o contêiner home_app está se comunicando corretamente com o book_details_app.
    • Ver avaliações de livros: clique em um link de avaliação para verificar se o contêiner home_app pode se comunicar com o contêiner book_reviews_app.

Seu app agora está em execução em um cluster do GKE.

Parabéns! Você aprendeu a transformar um app monolítico em um sistema modular e em contêineres que é executado em um cluster do GKE ativo. Ao longo do processo, você aprendeu a dividir códigos com acoplamento rígido em módulos independentes, criar e enviar imagens do contêiner para um repositório, definir manifestos do Kubernetes e implantar seu 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, 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 conforme o esperado:

kubectl get pods

Revise 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 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 tempo de execução.

Descrever um pod para informações detalhadas

Se um pod permanecer em um estado diferente de Running por mais de cinco minutos, por exemplo, se estiver em um estado Pending, ContainerCreating ou CrashLoopBackOff, será possível ver 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 que você quer detalhes.

A seção Events na saída pode indicar que restrições de recursos ou problemas com extrações de imagens 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, principalmente o que expõe o módulo inicial com um endereço IP externo. Liste os serviços com o comando a seguir:

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

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

kubectl get events

Esse comando pode determinar se problemas mais amplos de recursos ou rede 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 extras. 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. Informe 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 de novo.

(Opcional) Excluir o projeto do Google Cloud

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

  1. No console do Google Cloud , 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 que é executado em um cluster do Kubernetes. As etapas a seguir resumem o processo:

  1. Entender o monolítico

    • Analisou a estrutura do app monolítico Cymbal Books.
    • Configurar um ambiente local do Python para executar o monolítico e testar os endpoints dele.
    • 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.
    • Viu 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 conteinerização

    • Você aprendeu que é preciso atualizar os URLs em home.py para usar nomes de serviço em vez de localhost.
    • Você 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. Colocar o app modular em um contêiner

    • Configurar um projeto do Google Cloud e clonar o app do GitHub no Cloud Shell.
    • Criou imagens do 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.
    • Atualizamos 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.
    • Testamos 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.