Bem-vindo ao primeiro tutorial de uma série que lhe mostra como pegar num monolito (ou numa app monolítica), separá-lo em módulos, colocar os módulos em contentores e implementar as imagens de contentores num cluster do Google Kubernetes Engine (GKE). Não se preocupe se não compreender algum destes termos. Vai saber o que significam à medida que avança na série.
O percurso de aprendizagem é composto pelos seguintes tutoriais:
- Overview
- Compreenda o monolito (este tutorial)
- Modularize o monolítico
- Prepare a app modular para a contentorização
- Coloque a app modular em contentores
- Implemente a app num cluster do GKE
Neste tutorial, vai aprender sobre o monolito através dos seguintes passos:
- Configurar a app na sua máquina local.
- Explorar as respetivas funcionalidades no navegador.
- Rever o código.
O que é um monolito?
Antes de ter o exemplo de monolito da Cymbal Books em funcionamento, é importante compreender primeiro o que é um monolito.
Um monólito é uma app em que todos os componentes estão interligados e não podem ser dimensionados de forma independente. Por exemplo, se um número de utilizadores visitar subitamente a página de início de sessão da app, não pode dimensionar apenas o componente de início de sessão de forma independente. Em alternativa, tem de dimensionar toda a aplicação, incluindo componentes não relacionados, como o catálogo de produtos ou o sistema de processamento de encomendas.
Por outro lado, quando uma aplicação é dividida em módulos independentes, cada módulo pode ser dimensionado separadamente com base nas suas necessidades de recursos. Se alojar a app modular num cluster do GKE, o GKE pode até automatizar o dimensionamento por si.
O termo monolítico não significa código mal organizado. Um monolítico pode ser bem estruturado e os respetivos componentes podem ser implementados em áreas distintas do código. O que distingue um monolito é que estes componentes não podem ser executados nem dimensionados de forma independente.
Custos
Pode concluir este tutorial sem incorrer em custos. No entanto, se seguir os passos no tutorial final desta série, incorre em custos na sua conta doGoogle Cloud . Os custos começam quando ativa o GKE e implementa a app Cymbal Books num cluster do GKE. Estes 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, certifique-se de que desativa o GKE ou elimina o projeto assim que concluir este tutorial.
Antes de começar
Este tutorial requer a versão 3.13 do Python na sua máquina local. Para verificar a versão do Python no seu computador, execute este comando:
python3 --version
Se a sua versão do Python for anterior à 3.13, transfira e instale a versão mais recente a partir do Website oficial do Python.
Configure o seu ambiente
Nesta série de tutoriais, executa diferentes versões da aplicação em diferentes locais:
- A versão monolítica na sua máquina local
- A versão modular na sua máquina local
- A versão em contentor no Cloud Shell e, em seguida, num cluster do GKE
Nesta secção, configura um ambiente virtual na sua máquina local onde o monolito pode ser executado.
Transfira o código
Abra um terminal na sua máquina local.
Clone o repositório do GitHub do tutorial para a sua máquina local:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.gitA pasta
kubernetes-engine-samples/quickstarts/monolith-to-microservicescontém as seguintes três pastas:monolith/,modular/econtainerized/. Neste tutorial, vai focar-se exclusivamente nos ficheiros na pastamonolith/.
Crie e ative um ambiente virtual
Um ambiente virtual oferece um espaço isolado para executar a app. Impede que as bibliotecas Python que precisa de instalar para a app interfiram com outros projetos Python no seu sistema.
Siga estes passos para criar e ativar um ambiente virtual:
No terminal que abriu na secção anterior, navegue para a seguinte pasta no repositório que clonou anteriormente para a sua máquina:
cd kubernetes-engine-samples/quickstarts/monolith-to-microservicesCrie um ambiente virtual denominado
book-review-env:python3 -m venv book-review-envCriar um ambiente virtual é uma boa ideia porque é uma área onde pode executar a app isoladamente. Isto garante que as dependências e as configurações da app não entram em conflito com outro software ou bibliotecas no seu sistema.
Ative o ambiente virtual através do comando para o seu sistema operativo:
macOS e Linux
source book-review-env/bin/activateWindows
book-review-env\Scripts\activateInstale as dependências do Python para o monolito. As dependências são bibliotecas Python externas das quais a app depende para funcionar corretamente. Estas bibliotecas estão listadas no ficheiro
requirements.txte o seguinte comando instala todas elas no seu ambiente virtual:pip install -r monolith/requirements.txt
Execute e explore o Cymbal Books no navegador
A app Cymbal Books é intencionalmente simples e tem as seguintes funcionalidades:
- Uma página inicial que mostra todos os livros na biblioteca.
- Uma página que mostra detalhes sobre um livro.
- Um botão na página de detalhes que, quando clicado, mostra críticas de livros.
- A capacidade de apresentar imagens de capas de livros.
A página inicial apresenta três livros e um botão Ver detalhes junto a cada um deles:
Agora que o ambiente virtual está ativo e as dependências da app estão instaladas nesse ambiente, execute a app seguindo estes passos:
Na sua máquina local, navegue para o diretório monolith:
cd monolith/Inicie a app:
python3 mono.pyAbra o navegador de Internet e aceda à página inicial da app:
http://127.0.0.1:8080.Para aceder à página de detalhes de um livro, clique em Ver detalhes. A página de detalhes oferece mais informações sobre um livro, como o autor e o ano de publicação.
Para apresentar uma lista de críticas do livro, numa página de detalhes, clique em Mostrar críticas. A imagem seguinte mostra a página de detalhes do livro O Relógio de Zéfiro e a primeira crítica do livro:
Explore os ficheiros na pasta /monolith
Dedique algum tempo a examinar os ficheiros 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 ficheiros são os seguintes:
A pasta
images/contém as seguintes imagens de capas de livros, que são apresentadas na app:fungi_frontier.jpgmelodic_mechanics.jpgzephyrs_timepiece.jpg
A pasta
data/contém os seguintes ficheiros JSON. Estes ficheiros contêm críticas dos três livros na biblioteca da Cymbal Books e detalhes sobre cada livro:reviews-1.json,reviews-2.json,reviews-3.jsonbook-1.json,book-2.json,book-3.json
Embora as apps do mundo real usem frequentemente bases de dados, o armazenamento dos dados da app em ficheiros JSON simplifica a respetiva implementação. A app de exemplo Cymbal Book usa ficheiros JSON para que não tenha de processar código complexo. Em vez disso, pode focar-se no objetivo principal desta série de tutoriais, que é aprender a modularizar e a colocar o monolítico em contentores.
Pode ignorar as seguintes pastas porque os ficheiros nelas contidos são importantes para o esquema e o design da app, mas não são diretamente relevantes para a lógica da app:
static/: contém ficheiros CSS que definem o estilo da app.templates/: contém ficheiros HTML que definem o esquema e o conteúdo da app.
Compreenda o monolítico como uma aplicação Flask
O monolito neste tutorial é criado com o Flask, que é uma biblioteca Python para criar apps Web. No entanto, o Flask não é normalmente usado em ambientes de produção porque não suporta a concorrência, o que pode levar a gargalos de desempenho sob carga pesada. Uma aplicação Flask também não tem funcionalidades de escalabilidade e processamento de erros robustas.
A app Cymbal Books usa o Flask porque a sua simplicidade e configuração mínima facilitam a compreensão dos conceitos de modularização e contentorização. Para aplicações de nível de produção que usam Python, considere alternativas ao Flask, como o FastAPI ou o Django. Também pode usar frameworks adaptados a outros idiomas, como o Spring Boot para Java ou o Express.js para Node.js. Estas estruturas podem oferecer melhor concorrência, escalabilidade e capacidades prontas para produção para satisfazer as exigências das aplicações do mundo real.
Examine o ficheiro mono.py
Toda a lógica do monolito está contida num único ficheiro denominado mono.py. Este ficheiro cria uma aplicação Flask. Uma aplicação Flask é executada num servidor Web,
ouve URLs específicos, denominados pontos finais, e responde a pedidos
feitos a esses URLs. Quando alguém pede um destes URLs, seja
visitando-o num navegador de Internet ou fazendo o pedido programaticamente, o Flask executa
a parte do código correspondente para processar esse pedido.
A captura de ecrã seguinte mostra o ficheiro mono.py. As caixas realçam os controladores de rotas da app. Embora um controlador sirva a página inicial
orientada para o utilizador, os outros são usados principalmente para comunicação
entre módulos, fornecendo dados no formato JSON ou ficheiros de imagens estáticas. Pode encontrar mais detalhes
acerca destes pontos finais nas secções seguintes.
Na captura de ecrã, as caixas realçam os controladores de rotas da app. Um controlador de rotas é composto por duas partes:
- A linha
@app.route()que define um padrão do URL (como/book/<id>/reviews). - A função que é executada quando o ponto final é chamado.
Um ponto final é um URL que corresponde ao padrão definido na linha @app.route().
Por exemplo, quando um utilizador clica em Mostrar críticas na página de detalhes de um livro, a app faz um pedido a http://localhost:8080/book/1/reviews. O controlador de rotas book reviews
responde a este pedido executando os seguintes passos:
- Reconhece que este URL corresponde ao respetivo padrão
/book/<id>/reviews. - Obtém as críticas do livro 1 a partir de um ficheiro JSON.
- Envia essas críticas de volta para o front-end no formato JSON.
Em seguida, o componente de detalhes do livro apresenta estas críticas de forma legível na página Web. O monolito Cymbal Books usa uma biblioteca Python denominada Flask para simplificar a implementação de controladores de rotas. No tutorial seguinte, vai ver que o Flask e os controladores de rotas desempenham um papel crucial quando aprender como o monólito é convertido numa app modular.
Por que motivo os pontos finais do monólito são importantes para a modularização
Os pontos finais desempenham um papel fundamental nas aplicações Flask, incluindo a app Cymbal Books. No entanto, a sua importância vai além do design monolítico, porque a compreensão dos pontos finais é essencial para dividir a app em módulos independentes. Veja o motivo:
- Funcionalidades essenciais: os pontos finais implementam as funcionalidades principais da app, como apresentar páginas ou obter dados. Cada funcionalidade está associada a um ponto final específico.
- Modularização: os pontos finais atuam como limites naturais ou linhas de falha, para dividir a app em módulos mais pequenos. Como vai ver no tutorial seguinte, cada módulo na versão modular da app corresponde a uma funcionalidade com os seus próprios pontos finais.
- Comunicação: num design modular, os pontos finais permitem que os módulos autónomos comuniquem entre si. Compreender como os pontos finais são implementados no
mono.pyprepara o terreno para modularizar a app Cymbal Books em módulos independentes no próximo tutorial.
Teste os controladores de rotas do monolítico
Para ver que tipo de dados cada controlador de rotas devolve, visite os seguintes pontos finais no seu navegador:
- Handler da rota da página inicial: visite
http://localhost:8080/para ver uma página HTML completa que apresenta o catálogo de livros. - Book details route handler: visite
http://localhost:8080/book/1para ver uma página HTML que mostra detalhes sobre um livro específico. A página obtém dados JSON sobre um livro do servidor e apresenta-os num formato legível através de um modelo HTML. Experimente ver detalhes de outros livros alterando o número de ID (1, 2 ou 3) no URL. - Book reviews route handler: visite
http://localhost:8080/book/3/reviewspara ver os dados JSON das críticas do livro. Estes dados são processados num formato legível quando clica emShow Reviewsna página de detalhes do livro Melodic Mechanics. - Controlador de rotas de imagens: visite
http://localhost:8080/images/fungi_frontier.jpgpara ver um ficheiro de imagem. A página inicial e as páginas de detalhes dos livros chamam este endpoint para apresentar as imagens das capas dos livros.
Resumo
Neste tutorial, configurou e executou a app monolítica Cymbal Books. Em seguida, ficou a saber que o monólito é implementado como uma aplicação Flask, que escuta URLs específicos, denominados pontos finais, e responde a pedidos feitos a esses URLs.
O que se segue?
No tutorial seguinte, Modularize the monolith (Modularize o monolítico), vai ver como dividir o monolítico em módulos independentes.