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:
- Visão geral
- Entender o monolítico
- Modularizar o monolítico
- Preparar o app modular para a criação de contêineres
- Colocar o app modular em um contêiner
- 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.
Acesse o console doGoogle Cloud .
No console, clique no botão Ativar o Cloud Shell:
Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console.
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.Crie um cluster do GKE:
gcloud container clusters create CLUSTER_NAME \ --zone=ZONE \ --num-nodes=2
Substitua:
CLUSTER_NAME
: um nome para o cluster, comocymbal-cluster
.ZONE
: a zona em que você quer criar o cluster, comous-central1-a
oueurope-west1-b
. Para uma lista completa de zonas disponíveis, consulte Regiões e zonas.
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 okubectl
exige para interagir com o cluster do GKE.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:
Navegue até o diretório raiz do aplicativo em contêiner:
cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/
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 tipoLoadBalancer
fornecem acesso externo ao app.EXTERNAL-IP
: para um serviço do tipoLoadBalancer
, o campoEXTERNAL-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 tipoClusterIP
, esse campo fica vazio porque os serviçosClusterIP
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:
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 ahome-app-service
.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.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:
Recupere o endereço IP externo do
home-app-service
conforme descrito acima.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
ebook_details_app
estarão se comunicando com o contêinerimages_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 obook_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êinerbook_reviews_app
.
- 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
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, comocymbal-cluster
.ZONE
: a zona em que o cluster foi criado, comous-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:
- No console Google Cloud , abra a página Gerenciar recursos.
- Selecione o projeto que você quer excluir.
- 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:
-
- 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.
-
- 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.
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 delocalhost
. - 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.
- Aprendi que você precisava atualizar os URLs em
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.
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.