Executando verificação de segurança...
1
Spike
3 min de leitura ·

Preciso de Ajuda com a arquitetura do meu projeto

Fala meus consagrados!

Seguinte, preciso da ajuda dos Dev's mais experientes com relação a um projeto que estou fazendo. A ideia é transformar em um produto que me traga algum retorno financeiro (estou desempregado, já que ninguém me contrata, quero tentar caminhar com minhas próprias pernas).

Para ter um produto, estou levando em consideração alguns requisitos que tragam seriedade e confiabilidade para o que estou fazendo, dentre eles:

  • Interface e funcionalidades pragmáticas e de fácil utilização pelo usuário
  • Tratamento de erros de ponta a ponta
  • Utilização eficiente dos recursos de nuvem (distribuição adequada do processamento das funcionalidades)
  • Eliminar ao máximo a ideia de "reinventar a roda"

Para manter a minha aplicação sem trazer dores de cabeça, projetei uma arquitetura tentando abranger ao máximo o meu conhecimento. Porém, estou um pouco confuso com o fluxo das requisições e ainda não sei se estou fazendo da forma mais simples e confiável possível.

Permitam-me apresentar o estado atual da arquitetura. A lista de elementos da aplicação é:

  • Projeto em Java Spring Boot
  • Deploy via AWS ou Oracle Cloud
  • Serviço de Front-End (onde estão as páginas HTML, CSS e JavaScript que consome as API's)
  • Serviço Gateway para gerar a autenticação e consumir tudo de um mesmo endpoint
  • Serviço Load Balancer para distribuir a carga de maneira inteligente
  • Serviço API Enlace (é a API principal, onde armazeno informações no banco MySQL e entrego as funcionalidades principais que geram valor para o usuário)
  • Serviço API Pagamento (cuida apenas de realizar pagamentos e devolve informações para a API Enlace)
  • Serviço API Insta (API para realizar uma consulta ao Instagram)
  • Serviço Docker Image Instagrapi (uma biblioteca Python para consumir informações básicas do Instagram)

A arquitetura funciona assim:

  • Todos os serviços estarão em containers separados
  • A requisição sai do front-end, entra no Gateway, passa pelo Load Balancer e é enviado para a API Principal
  • A API Principal consome os serviços do Insta, Banco de Dados e Pagamentos

Minhas dificuldades e dúvidas atuais são:

  • Essa arquitetura é a mais confiável e menos problemática? Existem formas mais simples e igualmente confiáveis?
  • Quero usar o servidor NGinx ao invés do TomCat, que aparentemente ajuda a balancear carga. Onde ele ficaria inserido no meio disso tudo?
  • O Load Balancer só se conectará com a API Principal. É através da API Principal que os demais serviços serão consumidos. Isso faz sentido para o rendimento da aplicação?
  • Usar o Gateway para cuidar da autenticação garantirá a segurança dos outros serviços?
  • Existem serviços como o AWS Gateway e Oracle Gateway. Isso substitui eu ter que programar um Gatewat na mão em Java?

Desde já agradeço qualquer ajuda de Devs que já precisaram levantar uma aplicação se preocupando com perfomance e confiabilidade. Não tenho pressa para fazer esse projeto e estou tentando me forçar a não fazer nada de forma amadora. Uma luz agora no meio desse amontoado de problemas será de muito valor para mim.

Carregando publicação patrocinada...
1

Se for para estudo, acho que está ok criar uma arquitetura de microservices, mas caso esteja pensando em um produto real, eu não faria dessa forma no dia 0.

Pensando em desempenho e custo, eu escolheria Go para o backend, porque é compilado para um binário nativo e muito performatico, o que fará uma grande diferença no uso de CPU e memória nos seus servidores (o que vai reduzir seus custos para manter a solução no ar). Também, pensando em custo, não começaria o projeto no dia 0 com uma arquitetura de microservices. Um monólito bem escrito e modular trará muito menos dores de cabeça, especialmente quando você for usar ferramentas de monitoramento (Grafana, Prometheus ...).

E depois de um tempo, com o projeto já em produção, caso faça sentido, você pode separar alguma funcionalidade do projeto em um microserviço, o que normalmente ocorrerá quando você perceber a necessidade de escalar horizontalmente uma funcionalidade específica.