Percurso de aprendizagem: transforme um monolítico numa app do GKE – Implemente a app num cluster do GKE

Este é o quinto e último tutorial num percurso de aprendizagem que ensina a modularizar e colocar num contentor uma app monolítica.

O percurso de aprendizagem é composto pelos seguintes tutoriais:

  1. Overview
  2. Compreenda o monolito
  3. Modularize o monolítico
  4. Prepare a app modular para a contentorização
  5. Coloque a app modular em contentores
  6. Implemente a app num cluster do GKE (este tutorial)

No tutorial anterior, Coloque a app modular num contentor, preparou a app modular Cymbal Books para implementação. Colocou os módulos da app em contentores, testou os contentores resultantes e enviou as imagens de contentores para o Artifact Registry.

Neste tutorial, implementa a app contentorizada num cluster do Google Kubernetes Engine. Este passo conclui a transformação da app Cymbal Books num sistema modular e escalável que é executado num cluster do Kubernetes.

Custos

Seguir os passos neste tutorial implica encargos na sua Google Cloud conta. Os custos começam quando ativa o GKE e implementa a app de exemplo Cymbal Books. Estes custos incluem encargos por cluster do GKE, conforme descrito na página de preços, e encargos pela execução de VMs do Compute Engine.

Para evitar cobranças desnecessárias, certifique-se de que desativa o GKE ou elimina o projeto assim que concluir este tutorial.

Antes de começar

Antes de começar este tutorial, certifique-se de que concluiu os tutoriais anteriores da série. Para uma vista geral da série completa e links para tutoriais específicos, consulte o Percurso de aprendizagem: transforme um monolítico numa app do GKE – Vista geral.

Em particular, tem de ter realizado os passos no tutorial anterior, Coloque a app modular num contentor.

Configure o cluster do GKE

Antes de poder implementar a app modular Cymbal Books, tem de criar primeiro um cluster do GKE. Este cluster fornece a infraestrutura na qual os contentores da sua app vão ser executados.

Neste tutorial, vai usar a CLI gcloud para criar o cluster. Em alternativa, pode usar a Google Cloud consola, que oferece uma interface gráfica do utilizador (GUI) para criar e gerir Google Cloud recursos, como clusters do GKE.

Crie e valide um cluster do GKE

Um cluster do GKE fornece os recursos de computação necessários para executar os seus contentores no Kubernetes. Siga estes passos para criar um cluster com a CLI gcloud.

  1. Aceda à Google Cloud consola.

  2. Na consola, clique no botão Ativar Cloud Shell: Ativar Cloud Shell

    É aberta uma sessão do Cloud Shell num frame na parte inferior da consola.

  3. Defina o projeto predefinido na CLI Google Cloud:

    gcloud config set project PROJECT_ID

    Substitua PROJECT_ID pelo ID do projeto que criou ou selecionou na secção selecione ou crie um Google Cloud projeto da secção anterior. Um ID do projeto é uma string exclusiva que distingue o seu projeto de todos os outros projetos no Google Cloud. Para localizar o ID do projeto, aceda ao seletor de projetos. Nessa página, pode ver os IDs 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 o seguinte:

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

    • CONTROL_PLANE_LOCATION: a localização do Compute Engine do plano de controlo do seu cluster. Indique 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 estabelecer ligação ao cluster:

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

    Este comando atualiza o ficheiro de configuração do Kubernetes, que é armazenado por predefinição em ~/.kube/config. Este ficheiro de configuração contém as credenciais que o kubectl requer para interagir com o seu cluster do GKE.

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

    kubectl get nodes

    Se a configuração for bem-sucedida, este comando apresenta os nós no seu cluster do GKE. Como criou o cluster com --num-nodes=2, deve ver informações sobre dois nós, semelhantes às seguintes:

    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, ambos os nós estão no estado Ready. Este estado significa que o cluster do GKE está pronto para alojar as suas cargas de trabalho contentorizadas!

Implemente a app

Agora que criou um cluster do GKE, pode implementar a app Cymbal Books no mesmo. Para implementar uma app num cluster, aplica o manifesto do Kubernetes ao cluster.

Aplique o manifesto do Kubernetes

No Cloud Shell, implemente a app no cluster do GKE executando os seguintes comandos:

  1. Navegue para o diretório raiz da aplicação contentorizada:

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

  2. Aplique o manifesto do Kubernetes:

    kubectl apply -f kubernetes_manifest.yaml

O comando anterior indica ao Kubernetes que crie os recursos especificados no ficheiro kubernetes-manifest.yaml. Estes recursos incluem serviços, uma implementação e pods.

Encontrou os serviços pela primeira vez na secção Altere o código modular do tutorial Prepare a app modular para a contentorização. Nesse tutorial, atualizou o código da app para usar nomes de serviços em vez de localhost. Essa atualização permite que o Kubernetes encaminhe pedidos entre módulos e garante que os módulos podem comunicar entre si num cluster. Agora, quando aplica o manifesto, o Kubernetes cria os serviços no cluster.

Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster. A secção seguinte explica o que são os pods.

O que é um pod do Kubernetes?

No tutorial anterior, criou uma imagem de contentor para cada módulo da app Cymbal Books. Por exemplo, criou imagens de contentores com base nos módulos home_app e book_details_app.

Quando usa o comando kubectl apply para implementar o manifesto do Kubernetes, o Kubernetes extrai as imagens de contentores do Artifact Registry para o cluster. No cluster, as imagens de contentores tornam-se contentores e os contentores são executados em pods.

Um pod é um ambiente isolado no qual os contentores são executados e realiza as seguintes tarefas:

  • Atribui CPU e memória: um pod fornece os recursos de que os contentores precisam para funcionar.
  • Fornece rede: cada Pod tem o seu próprio endereço IP. Isto permite que o Pod 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 distribui os pods pelos nós do cluster para reduzir o risco de sobrecarregar um único nó. Esta distribuição ajuda o cluster a usar os respetivos recursos de computação e memória de forma eficiente.

Valide a implementação

Depois de aplicar o manifesto do Kubernetes com o comando kubectl apply, verifique se a app foi implementada com êxito no cluster. Para verificar a implementação, certifique-se de que os pods e os serviços estão a ser executados corretamente.

Verifique os pods

Para ver os pods no seu cluster, execute o seguinte comando:

kubectl get pods

Este comando apresenta os pods e o respetivo estado atual. Procure a coluna STATUS para confirmar que todos os pods estão marcados como Running, o que indica que estão a ser executados com êxito e prontos para publicar pedidos. O resultado esperado tem o seguinte aspeto:

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 estado de um pod aparece inicialmente como Pending enquanto está a ser criado e os respetivos contentores estão em processo de início. Se um pod permanecer Pending durante um período prolongado, o cluster pode não ter recursos suficientes para que esse pod entre num estado Running saudável. Se um pod tiver o estado CrashLoopBackOff, pode haver um problema com o contentor. Os passos de resolução de problemas são fornecidos mais adiante no tutorial.

Verifique os serviços

Os serviços permitem a comunicação entre os pods e permitem que os clientes externos (por exemplo, utilizadores, scripts automatizados ou ferramentas de monitorização) acedam à app. Para ver os serviços no seu cluster, execute o seguinte comando:

kubectl get services

A saída deste comando tem o seguinte aspeto:

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 campos principais a observar na saída são os seguintes:

  • TYPE: este campo indica como o serviço é exposto. Os serviços do tipo LoadBalancer oferecem acesso externo à app.
  • EXTERNAL-IP: para um serviço do tipo LoadBalancer, o campo EXTERNAL-IP mostra o endereço IP público que os utilizadores podem introduzir no respetivo navegador de Internet para aceder à app. Para um serviço do tipo ClusterIP, este campo está vazio porque os serviços ClusterIP só são acessíveis no cluster.

Teste a implementação

Depois de implementar a app Cymbal Books no cluster do GKE, verifique se a app está acessível e se os contentores conseguem comunicar entre si.

Aceda à app

Confirme se a app está acessível seguindo estes passos:

  1. Recupere o endereço IP externo para o home-app-service:

    kubectl get services

    Procure a coluna **EXTERNAL-IP** no resultado e tome nota do endereço IP associado a home-app-service.

  2. Abra um navegador de Internet e introduza o seguinte URL:

    http://EXTERNAL-IP

    Substitua EXTERNAL-IP pelo endereço IP que encontrou no passo anterior.

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

Valide a comunicação entre serviços

Os contentores na app Cymbal Books dependem dos serviços para trocar informações. Certifique-se de que os contentores conseguem comunicar eficazmente seguindo estes passos:

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

  2. Use a interface da app para testar as interações entre contentores. Para tal, confirme que as seguintes funcionalidades funcionam clicando em todos os links disponíveis na interface da app:

    • Verifique as imagens das capas dos livros: confirme se as imagens das capas dos livros são carregadas corretamente na página inicial e na página de detalhes do livro. Se o fizerem, os contentores home_app e book_details_app estão a comunicar com êxito com o contentor images_app.
    • Ver detalhes do livro: navegar para uma página de detalhes do livro a partir da página inicial. Se vir os detalhes de um livro, o contentor home_app está a comunicar corretamente com o book_details_app.
    • Ver críticas de livros: clique num link de crítica de um livro para verificar se o contentor home_app consegue comunicar com o contentor book_reviews_app.

A sua app está agora a ser executada num cluster do GKE!

Parabéns! Viu como transformar uma app monolítica num sistema modular e contentorizado que é executado num cluster do GKE em direto. Ao longo do caminho, aprendeu a dividir o código fortemente acoplado em módulos independentes, a criar e enviar imagens de contentores para um repositório, a definir manifestos do Kubernetes e a implementar a sua app do registo para o GKE. Este é um feito importante e reflete os passos que as equipas dão no mundo real para modernizar as aplicações para a nuvem!

Resolução de problemas

Se a app não responder ou os contentores não comunicarem, siga estes passos de resolução de problemas para diagnosticar e resolver problemas comuns.

Verifique o estado dos seus Pods

Comece por listar todos os pods no cluster para determinar se estão a ser executados conforme esperado:

kubectl get pods

Reveja a saída para confirmar que cada Pod está no estado Running. Se algum pod não estiver em execução, anote o respetivo nome para inspeção adicional.

Inspecione os registos de pods

Se um Pod não estiver a processar pedidos corretamente, verifique os respetivos registos para procurar mensagens de erro:

kubectl logs POD_NAME

Substitua POD_NAME pelo nome do Pod que quer inspecionar. Este comando é útil para identificar problemas de arranque ou erros de tempo de execução.

Descreva um Pod para obter informações detalhadas

Se um Pod permanecer num estado não Running durante mais de cinco minutos, por exemplo, num estado Pending, ContainerCreating ou CrashLoopBackOff, pode ver informações detalhadas sobre o estado e os eventos do Pod através do seguinte comando:

kubectl describe pod POD_NAME

Substitua POD_NAME pelo nome do Pod sobre o qual quer informações detalhadas.

A secção Events no resultado pode indicar que as restrições de recursos ou os problemas com as obtenções de imagens estão a impedir o início correto do pod.

Valide a configuração do serviço

Certifique-se de que os seus serviços estão configurados corretamente, especialmente o serviço que expõe o módulo doméstico com um endereço IP externo. Apresente uma lista dos serviços com o seguinte comando:

kubectl get services

Se reparar que o módulo Service for the home tem uma morada EXTERNAL-IP indicada como Pending, execute o seguinte comando:

kubectl describe service SERVICE_NAME

Substitua SERVICE_NAME pelo nome do módulo de casa Service.

Este 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.

Verifique os eventos de cluster

Pode examinar os eventos de cluster para determinar se um problema está a afetar vários componentes do cluster:

kubectl get events

Este comando pode determinar se problemas de recursos ou de rede mais amplos estão a afetar a sua implementação.

Limpe os recursos

A execução de um cluster do GKE incorre em custos. Depois de concluir este tutorial, limpe os seus recursos para evitar cobranças adicionais. Siga estes passos para remover o cluster e, opcionalmente, todo o projeto.

Elimine o cluster do GKE

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

gcloud container clusters delete CLUSTER_NAME
    --location=CONTROL_PLANE_LOCATION

Substitua o seguinte:

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

  • CONTROL_PLANE_LOCATION: a localização do Compute Engine do plano de controlo do seu cluster. Indique uma região para clusters regionais ou uma zona para clusters zonais.

Quando lhe for pedido, confirme a eliminação.

Verifique se o cluster foi eliminado

Para garantir que o cluster foi eliminado, execute o seguinte comando:

gcloud container clusters list

O cluster já não deve aparecer no resultado. Se aparecer, aguarde alguns momentos e tente novamente.

(Opcional) Elimine o Google Cloud projeto

Se criou um Google Cloud projeto especificamente para este tutorial e já não precisa dele, pode eliminar o Google Cloud projeto completo. A eliminação do projeto remove todos os recursos e interrompe a faturação do projeto:

  1. Na Google Cloud consola, abra a página Gerir recursos.
  2. Selecione o projeto que quer eliminar.
  3. Clique em Eliminar projeto e siga as instruções para confirmar.

Resumo da série

Parabéns! Ao concluir este percurso de aprendizagem, aprendeu os princípios básicos da conversão de uma app monolítica numa app modular e contentorizada que é executada num cluster do Kubernetes. Os passos seguintes resumem o processo:

  1. Compreenda o monolito

    • Explorou a estrutura da app monolítica Cymbal Books.
    • Configurou um ambiente Python local para executar o monolítico e testou os respetivos pontos finais.
    • Ter compreendido a base de código da app para a preparar para a modularização.

  2. Modularize o monolítico

    • Aprendeu a dividir o código monolítico em módulos separados. Cada módulo processa uma funcionalidade distinta, como a apresentação de detalhes ou críticas de livros.
    • Viu como estes módulos são implementados como apps Flask independentes em execução em portas diferentes.
    • Testou a app modularizada.

  3. Prepare o código modular para a contentorização

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

  4. Coloque a app modular em contentores

    • Configurou um Google Cloud projeto e clonou a app do GitHub para o Cloud Shell.
    • Criou imagens de contentores para cada módulo com o Docker e testou os contentores localmente.
    • Enviou as imagens de contentores para o Artifact Registry para preparar a app para a implementação num cluster.
    • Atualizou o manifesto do Kubernetes para fazer referência aos caminhos das imagens de contentores no Artifact Registry.

  5. Implemente a app num cluster do GKE (o tutorial em que se encontra agora):

    • Criou um cluster do GKE.
    • Implementou as imagens de contentores do Artifact Registry no cluster do GKE.
    • Testou a versão final da app, que agora é escalável e é executada num ambiente do Kubernetes!

O que se segue?

Para mais formação prática sobre como criar clusters, consulte a nossa série, Percurso de aprendizagem: aplicações escaláveis.