VIII. Concurrency – Escalar via o modelo de processos

Utilizar processos concorrentes para lidar com aumento de carga de forma eficiente

8º Fator: Escalabilidade Através do Modelo de Processos

O oitavo fator da metodologia de doze fatores foca na concorrência e na capacidade de escalar uma aplicação usando o modelo de processos. Este princípio permite que uma aplicação se expanda de forma previsível e confiável, lidando com diferentes tipos de cargas de trabalho e possibilitando que a aplicação cresça horizontalmente, executando vários processos em diferentes máquinas, se necessário.

Concorrência no Modelo de Processos

Quando uma aplicação é executada, ela é representada por um ou mais processos no sistema operacional. O modelo de processos adotado pela metodologia de doze fatores permite que a aplicação se escale de maneira horizontal, adicionando mais processos ao invés de tentar aumentar o tamanho ou a complexidade de um único processo. Isso é particularmente útil em ambientes modernos de microsserviços e containers, onde a capacidade de rodar múltiplos processos em paralelo é essencial.

No modelo tradicional, muitos frameworks e plataformas gerenciam os processos de forma invisível para os desenvolvedores. Por exemplo, um processo PHP rodando em Apache é iniciado conforme a necessidade de volume de requisições, enquanto no caso do Java, o JVM (Java Virtual Machine) cria um grande “uberprocesso” que gerencia a concorrência internamente via threads. No entanto, no modelo de doze fatores, o processo é uma entidade de primeira classe, e os desenvolvedores têm controle explícito sobre como a aplicação lida com a concorrência.

Angular e Concorrência no Cliente

Quando falamos de concorrência em Angular, estamos nos referindo principalmente à capacidade de entregar e baixar os arquivos estáticos (HTML, JavaScript, CSS) que compõem a aplicação Angular para o navegador do cliente. Após o download desses arquivos, a execução da aplicação ocorre inteiramente no navegador, o que significa que não há concorrência direta no processamento da aplicação Angular em si no servidor. Toda a carga de processamento da interface de usuário (UI), interações, e renderização é tratada pela máquina do cliente.

No entanto, existem dois momentos em que a concorrência afeta o desempenho de uma aplicação Angular:

1. Concorrência na Entrega dos Arquivos: A principal carga que a aplicação Angular impõe ao servidor é durante o download dos arquivos estáticos (JavaScript, HTML, CSS, imagens, fontes, etc.). Isso significa que, se houver muitos usuários tentando acessar a aplicação ao mesmo tempo, o servidor que hospeda esses arquivos pode enfrentar limitações de largura de banda ou processamento de requisições simultâneas.
   • Impacto no Servidor: A entrega dos arquivos estáticos é a parte em que a concorrência realmente afeta o servidor. Se muitos usuários solicitarem esses arquivos ao mesmo tempo, o servidor precisa ser capaz de lidar com essas solicitações simultâneas. Isso pode ser tratado escalando horizontalmente o servidor web ou utilizando uma Content Delivery Network (CDN), que replica os arquivos estáticos em múltiplos servidores distribuídos geograficamente, reduzindo a carga sobre o servidor principal.
   • Uso de CDNs: A maioria das aplicações modernas utiliza CDNs para distribuir os arquivos estáticos do frontend, incluindo o próprio código Angular. Isso garante que, independentemente da localização do cliente ou do número de acessos simultâneos, os arquivos estáticos possam ser entregues rapidamente, sem sobrecarregar um único servidor.
2. Concorrência nas Chamadas ao Backend: Embora o Angular seja executado no lado do cliente, ele frequentemente se comunica com um backend para buscar dados, autenticar usuários, ou realizar outras operações. Essa comunicação é feita através de chamadas HTTP (normalmente APIs REST ou GraphQL). Aqui, o backend é a parte que pode ser afetada pela concorrência.
   • Processos de Backend: O backend da aplicação precisa ser escalável e capaz de lidar com várias requisições simultâneas do Angular. Se muitos usuários estiverem utilizando a aplicação Angular ao mesmo tempo, a quantidade de chamadas feitas para a API pode crescer rapidamente, exigindo que o backend lide com essa carga.
   • Exemplo de Processo Web: Se o Angular está realizando muitas chamadas para buscar dados, o backend pode começar a escalar horizontalmente adicionando mais processos para atender a essas requisições. O modelo de processos da metodologia de doze fatores é ideal para lidar com esse tipo de concorrência, uma vez que permite escalar o backend adicionando mais instâncias do serviço web sem afetar a lógica da aplicação Angular.

Concorrência no Angular: Como o Backend é Atingido

Vamos explorar como a concorrência afeta o backend que serve uma aplicação Angular:

1. Chamadas Assíncronas (HTTP Requests): Quando o Angular faz chamadas assíncronas para buscar dados de uma API, cada requisição precisa ser atendida por um servidor backend. Se a aplicação Angular estiver sendo usada por muitos usuários ao mesmo tempo, isso pode resultar em uma grande quantidade de requisições simultâneas ao backend.Aqui, o modelo de processos do backend precisa ser capaz de escalar horizontalmente. Se você está usando uma arquitetura baseada em microsserviços ou containers, como Node.js, Spring Boot, ou Python Flask, você pode facilmente adicionar mais instâncias de serviços backend para lidar com a carga crescente.
2. Operações Longas e Processamento em Background: Algumas aplicações Angular podem envolver operações de longa duração, como geração de relatórios, processamento de imagens, ou cálculos complexos. Embora o frontend Angular apenas envie a solicitação, o backend pode usar processos de worker para lidar com essas operações em segundo plano, liberando o servidor web para continuar lidando com as requisições do cliente.Exemplo de Escalabilidade com Processos de Worker: Se sua aplicação Angular permite que os usuários solicitem um relatório gerado dinamicamente, o backend pode usar um processo de worker separado para gerar o relatório. Isso evita que o servidor web fique bloqueado ou sobrecarregado com essa operação. Quando o relatório estiver pronto, o usuário pode ser notificado no frontend, e o resultado pode ser recuperado.

Escalabilidade e Concorrência no Angular: Boas Práticas

1. CDN para Arquivos Estáticos: Uma das melhores maneiras de lidar com a concorrência durante o download dos arquivos estáticos de uma aplicação Angular é usando uma CDN. Isso garante que os arquivos estão distribuídos em servidores geograficamente próximos aos usuários, melhorando a performance e reduzindo a carga sobre o servidor de origem.
2. API Gateways e Load Balancers: Para garantir que o backend que serve uma aplicação Angular possa lidar com requisições concorrentes, o uso de API Gateways e Load Balancers é essencial. Essas ferramentas distribuem as requisições entre diferentes instâncias do backend, permitindo que a aplicação escale horizontalmente e lide com picos de tráfego sem interrupções.
3. Caching Estratégico: O caching é outra estratégia importante para mitigar a concorrência no backend de uma aplicação Angular. Ao cachear respostas de APIs que mudam raramente, você reduz a necessidade de chamadas repetitivas ao backend, aliviando a carga nos servidores.
4. Escalabilidade Horizontal com Containers: O uso de Docker e Kubernetes permite que o backend de uma aplicação Angular escale horizontalmente de forma simples e automatizada. Quando a demanda aumenta, novas instâncias dos serviços podem ser criadas dinamicamente, garantindo que as requisições sejam atendidas sem problemas de concorrência.

Conclusão

Embora o Angular seja um framework frontend que roda no lado do cliente, ele ainda é impactado pela concorrência, especialmente durante o download dos arquivos estáticos e nas interações com o backend via APIs. O oitavo fator da metodologia de doze fatores — concorrência via o modelo de processos — é mais aplicável ao backend que serve a aplicação Angular e as APIs que ela consome. Garantir que o backend seja escalável horizontalmente, que os arquivos estáticos sejam entregues de forma eficiente, e que o uso de processos de worker para tarefas longas seja implementado são práticas essenciais para garantir que a aplicação Angular seja capaz de lidar com alta concorrência de maneira eficiente.