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 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 a criação de contêineres
  5. Colocar o app modular em um contêiner
  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ê contêinerizou 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 em contêiner 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 do Google Cloud. Os custos começam quando você ativa o GKE e implanta o app de amostra 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 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 particular, 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, 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ê vai usar a CLI gcloud para criar o cluster. Como alternativa, use o console doGoogle Cloud , 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 conferir os IDs de cada um dos seus projetos do 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 criar o cluster, 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 o kubectl exige para interagir com o 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, é 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 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 de contêiner se tornam contêineres, e os contêineres são executados em 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.
  • Fornece rede: cada pod tem um endereço IP próprio. 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 sobrecarga em 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 sendo executados 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, talvez o cluster não tenha 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 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

Estes são os campos principais a serem observados na saída:

  • 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 de 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 acima.

  2. Use a interface do app para testar interações entre contêineres. Para fazer 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 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 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 estará se comunicando corretamente com o book_details_app.
    • Ver 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 contêiner 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 em contêineres que é executado em um cluster do GKE ativo. Ao longo do processo, você aprendeu a dividir códigos fortemente acoplados 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 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 como 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 posterior.

Inspecionar registros do pod

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 diferente de Running por mais de cinco minutos (por exemplo, em um estado Pending, ContainerCreating ou CrashLoopBackOff), use o seguinte comando para conferir informações detalhadas sobre o status e os eventos do pod:

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 pull de imagens estão impedindo que o pod seja iniciado corretamente.

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 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 residencial 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 home.

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 analisar 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 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 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 comando a seguir:

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.

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

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

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

  1. Entender o monolítico

    • Conheceu a estrutura do app monolítico Cymbal Books.
    • Configure um ambiente Python local para executar o monólito e testar os endpoints dele.
    • Entendeu a base de código do app para prepará-lo para a modularização.

  2. Modularizar o monolítico

    • Aprendi 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.
    • Você 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 contêinerização

    • Aprendi que você precisava 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

    • Configure um projeto Google Cloud e clone o app do GitHub no 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.
    • Atualizamos o manifesto do Kubernetes para se referir aos caminhos de imagens de contêiner no Artifact Registry.

  5. Implante 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 funciona 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.