Programa de treinamentos: transformar um monólito em um app do GKE: entender o monólito

Este é o primeiro tutorial de uma série que mostra como pegar um monólito (ou app monolítico), separá-lo em módulos, colocar os módulos em contêineres e implantar as imagens de contêiner em um cluster do Google Kubernetes Engine (GKE). Não se preocupe se você não entender algum desses termos. Você vai aprender o significado deles à medida que avançar na série.

O programa de aprendizado consiste nos seguintes tutoriais:

1. Visão geral
2. Entender o monolítico (este tutorial)
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

Neste tutorial, você vai aprender sobre o monólito realizando as seguintes etapas:

1. Configurar o app na máquina local.
2. Conheça os recursos dele no seu navegador.
3. Revisando o código.

O que é um monólito?

Antes de colocar o exemplo de monólito do Cymbal Books em funcionamento, é importante entender o que é um monólito.

Um monólito é um app em que todos os componentes estão interconectados e não podem ser escalonados de forma independente. Por exemplo, se vários usuários acessarem a página de login do app de repente, não será possível escalonar apenas o componente de login de forma independente. Em vez disso, você precisa escalonar todo o aplicativo, incluindo componentes não relacionados, como o catálogo de produtos ou o sistema de processamento de pedidos.

Por outro lado, quando um aplicativo é dividido em módulos independentes, cada módulo pode ser escalonado separadamente com base nas necessidades de recursos. Se você hospedar o app modular em um cluster do GKE, o GKE poderá até mesmo automatizar o escalonamento para você.

O termo monolítico não significa código mal organizado. Um monólito pode ser bem estruturado, e os componentes podem ser implementados em áreas distintas do código. O que distingue um monólito é que esses componentes não podem ser executados ou escalonados de forma independente.

Custos

Você pode concluir este tutorial sem custos. No entanto, seguir as etapas do tutorial final desta série gera cobranças na sua conta doGoogle Cloud . Os custos começam quando você ativa o GKE e implanta o app Cymbal Books em um cluster do GKE. 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

Este tutorial requer a versão 3.13 do Python na sua máquina local. Para verificar qual versão do Python está na sua máquina, execute este comando:

python3 --version

Se a versão do Python for anterior à 3.13, faça o download e instale a versão mais recente no site oficial do Python.

Configurar o ambiente

Nesta série de tutoriais, você executa diferentes versões do aplicativo em diferentes lugares:

• A versão monolítica na sua máquina local
• A versão modular na sua máquina local
• A versão conteinerizada no Cloud Shell e em um cluster do GKE

Nesta seção, você vai configurar um ambiente virtual na sua máquina local para executar o monólito.

Fazer o download do código

1. Abra um terminal na máquina local.

2. Clone o repositório do GitHub do tutorial na sua máquina local:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   

   A pasta kubernetes-engine-samples/quickstarts/monolith-to-microservices contém as seguintes três pastas: monolith/, modular/ e containerized/. Neste tutorial, você vai se concentrar exclusivamente nos arquivos da pasta monolith/.

Criar e ativar um ambiente virtual

Um ambiente virtual oferece um espaço isolado para executar o app. Ele evita que as bibliotecas Python que você precisa instalar para o app interfiram em outros projetos Python no seu sistema.

Siga estas etapas para criar e ativar um ambiente virtual:

1. No terminal que você abriu na seção anterior, navegue até a seguinte pasta no repositório clonado na sua máquina:

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

2. Crie um ambiente virtual chamado book-review-env:

   python3 -m venv book-review-env
   

   Criar um ambiente virtual é uma boa ideia porque é uma área em que você pode executar o app isoladamente. Isso garante que as dependências e configurações do app não entrem em conflito com outros softwares ou bibliotecas no seu sistema.

3. Ative o ambiente virtual usando o comando do seu sistema operacional:

   macOS e Linux

   source book-review-env/bin/activate
   

   Windows

   book-review-env\Scripts\activate
   

4. Instale as dependências do Python para o monólito. As dependências são bibliotecas Python externas de que o app precisa para funcionar corretamente. Essas bibliotecas estão listadas no arquivo requirements.txt, e o comando a seguir instala todas elas no seu ambiente virtual:

   pip install -r monolith/requirements.txt
   

Executar e conhecer o Cymbal Books no navegador

O app Cymbal Books é intencionalmente simples e tem os seguintes recursos:

• Uma página inicial que mostra todos os livros da biblioteca.
• Uma página que mostra detalhes sobre um livro.
• Um botão na página de detalhes que, quando clicado, mostra as avaliações do livro.
• A capacidade de mostrar imagens de capas de livros.

A página inicial mostra três livros, e um botão "Ver detalhes" aparece com cada um deles:

Agora que o ambiente virtual está ativo e as dependências do app estão instaladas nele, execute o app seguindo estas etapas:

1. Na máquina local, navegue até o diretório do monólito:

   cd monolith/
   

2. Inicie o app:

   python3 mono.py
   

3. Abra o navegador da Web e acesse a página inicial do app: http://127.0.0.1:8080.

4. Para acessar a página de detalhes de um livro, clique em Ver detalhes. A página de detalhes fornece mais informações sobre um livro, como autor e ano de publicação.

5. Para mostrar uma lista de avaliações do livro, clique em Mostrar avaliações na página de detalhes. A imagem a seguir mostra a página de detalhes do livro Zephyr's Timepiece e a primeira avaliação:

   

Confira os arquivos na pasta /monolith

Analise os arquivos na pasta /monolith:

monolith/
├── mono.py
├── data/
│   ├── book-1.json
│   ├── book-2.json
│   ├── book-3.json
│   ├── reviews-1.json
│   ├── reviews-2.json
│   └── reviews-3.json
├── images/
│   ├── fungi_frontier.jpg
│   ├── melodic_mechanics.jpg
│   └── zephyrs_timepiece.jpg
├── static/
│   ├── styles_for_details.css
│   └── styles_for_home.css
└── templates/
    ├── book_details.html
    └── home.html

As principais pastas e arquivos são:

• A pasta images/ contém as seguintes imagens de capa de livro, que são mostradas no app:

  • fungi_frontier.jpg
  • melodic_mechanics.jpg
  • zephyrs_timepiece.jpg

• A pasta data/ contém os seguintes arquivos JSON. Esses arquivos contêm avaliações dos três livros na biblioteca da Cymbal Books e detalhes sobre cada livro:

  • reviews-1.json, reviews-2.json, reviews-3.json
  • book-1.json, book-2.json, book-3.json

Embora os apps do mundo real geralmente usem bancos de dados, armazenar os dados do app em arquivos JSON simplifica a implementação. O app de exemplo Cymbal Book usa arquivos JSON para que você não precise lidar com códigos complexos. Em vez disso, você pode se concentrar no objetivo principal desta série de tutoriais, que é aprender a modularizar e colocar o monólito em contêineres.

Você pode ignorar as seguintes pastas porque os arquivos nelas são importantes para o layout e o design do app, mas não são diretamente relevantes para a lógica dele:

• static/: contém arquivos CSS que definem o estilo do app.
• templates/: contém arquivos HTML que definem o layout e o conteúdo do app.

Entender o monólito como um aplicativo Flask

O monólito deste tutorial é criado usando o Flask, que é uma biblioteca Python para criar aplicativos da Web. No entanto, o Flask não é usado normalmente em ambientes de produção porque não oferece suporte à simultaneidade, o que pode levar a gargalos de desempenho sob carga pesada. Um aplicativo Flask também não tem recursos robustos de tratamento de erros e escalonabilidade.

O app Cymbal Books usa o Flask porque a simplicidade e a configuração mínima facilitam a compreensão dos conceitos de modularização e contêinerização. Para aplicativos de nível de produção que usam Python, considere alternativas ao Flask como FastAPI ou Django. Também é possível usar frameworks feitos para outras linguagens, como o Spring Boot para Java ou o Express.js para Node.js. Esses frameworks podem oferecer melhor simultaneidade, escalonabilidade e recursos prontos para produção para atender às demandas de aplicativos do mundo real.

Analisar mono.py

Toda a lógica do monólito está contida em um único arquivo chamado mono.py. Esse arquivo cria um aplicativo Flask. Um aplicativo Flask é executado em um servidor da Web, fica atento a URLs específicos, chamados de endpoints, e responde a solicitações feitas a esses URLs. Quando alguém solicita um desses URLs, seja acessando-o em um navegador da Web ou fazendo a solicitação de forma programática, o Flask executa o trecho de código correspondente para processar essa solicitação.

A captura de tela a seguir mostra o arquivo mono.py. As caixas destacam os processadores de rotas do app. Enquanto um manipulador atende à página inicial voltada ao usuário, os outros são usados principalmente para comunicação entre módulos, entregando dados no formato JSON ou arquivos de imagem estáticos. Mais detalhes sobre esses endpoints são fornecidos nas próximas seções.

Na captura de tela, as caixas destacam os manipuladores de rotas do app. Um manipulador de rota consiste em duas partes:

• A linha @app.route() que define um padrão de URL (como /book/<id>/reviews).
• A função executada quando o endpoint é chamado.

Um endpoint é um URL que corresponde ao padrão definido na linha @app.route().

Por exemplo, quando um usuário clica em Mostrar avaliações na página de detalhes de um livro, o app faz uma solicitação para http://localhost:8080/book/1/reviews. O manipulador de rotas de avaliações de livros responde a essa solicitação seguindo estas etapas:

1. Reconhece que este URL corresponde ao padrão /book/<id>/reviews.
2. Recebe as avaliações do livro 1 de um arquivo JSON.
3. Envia essas avaliações de volta para o front-end no formato JSON.

O componente de detalhes do livro mostra essas avaliações de forma legível na página da Web. O monólito do Cymbal Books usa uma biblioteca Python chamada Flask para simplificar a implementação de manipuladores de rotas. No próximo tutorial, você vai ver que o Flask e os manipuladores de rotas desempenham um papel crucial ao aprender como o monólito é convertido em um app modular.

Por que os endpoints do monólito são importantes para a modularização

Os endpoints têm um papel fundamental em aplicativos Flask, incluindo o app Cymbal Books. No entanto, a importância deles vai além do design monolítico, porque entender os endpoints é essencial para dividir o app em módulos independentes. Geralmente, estes são os motivos:

• Recursos principais: os endpoints implementam os principais recursos do app, como mostrar páginas ou recuperar dados. Cada recurso está vinculado a um endpoint específico.
• Modularização: os endpoints atuam como limites naturais, ou linhas de falha, para dividir o app em módulos menores. Como você vai ver no próximo tutorial, cada módulo na versão modular do app corresponde a um recurso com endpoints próprios.
• Comunicação: em um design modular, os endpoints permitem que módulos autônomos se comuniquem entre si. Entender como os endpoints são implementados em mono.py prepara o terreno para modularizar o app Cymbal Books em módulos independentes no próximo tutorial.

Testar os manipuladores de rotas do monolítico

Para saber que tipo de dados cada manipulador de rotas retorna, acesse os seguintes endpoints no navegador:

• Processador de rotas da página inicial: acesse http://localhost:8080/ para ver uma página HTML completa que mostra o catálogo de livros.
• Gerenciador de rotas de detalhes do livro: acesse http://localhost:8080/book/1 para ver uma página HTML com detalhes sobre um livro específico. A página busca dados JSON sobre um livro no servidor e os apresenta de forma legível por humanos usando um modelo HTML. Para ver detalhes de outros livros, mude o número de ID (1, 2 ou 3) no URL.
• Processador de rotas de avaliações de livros: acesse http://localhost:8080/book/3/reviews para conferir os dados JSON das avaliações do livro. Esses dados são processados em um formato legível quando você clica em Show Reviews na página de detalhes do livro Melodic Mechanics.
• Gerenciador de rotas de imagens: acesse http://localhost:8080/images/fungi_frontier.jpg para ver um arquivo de imagem. A página inicial e as páginas de detalhes do livro chamam esse endpoint para mostrar as imagens da capa dos livros.

Resumo

Neste tutorial, você configurou e executou o app monolítico Cymbal Books. Depois, você aprendeu que o monólito é implementado como um aplicativo Flask, que fica aguardando URLs específicos, chamados de endpoints, e responde às solicitações feitas a esses URLs.

A seguir

No próximo tutorial, Modularizar o monolítico, você vai aprender a dividir o monolítico em módulos independentes.