Caixa de ferramentas da Arquitetura de Software: Como tornar suas aplicações mais escaláveis, confiáveis e seguras

Sumário

ISBN

Agradecimentos

Sobre o livro

Sobre o autor

Prefácio

Parte 1: Introdução à Arquitetura de Software

1 Arquitetura de software

2 Modelos de Arquitetura de Software

Parte 2: Desempenho

3 Desempenho

4 Desempenho e escalabilidade no código

5 Desempenho e escalabilidade na infraestrutura

Parte 3: Confiabilidade

6 Confiabilidade

7 Confiabilidade no código

8 Confiabilidade na infraestrutura

Parte 4: Segurança

9 Segurança

10 Segurança no código

11 Segurança na infraestrutura

Parte 5: Outros requisitos não funcionais

12 Outros requisitos

ISBN

Impresso: 978-85-5519-367-5

Digital: 978-85-5519-365-1

Caso você deseje submeter alguma errata ou sugestão, acesse http://erratas.casadocodigo.com.br.

Agradecimentos

Agradeço à minha família, meus pais, Luiz e Sonia, e meus irmãos, Luiz e Bruna. Sem eles, dificilmente teria chegado até aqui.

Agradeço à minha namorada, Brianda, que me acompanha em praticamente toda a minha vida profissional.

Agradeço também ao pessoal da Casa do Código, especialmente ao Antonio, pela ajuda e revisão na escrita deste livro.

Sobre o livro

Em um projeto de software, as pessoas desenvolvedoras se preocupam principalmente com o código, que vai executar algum requisito pedido pelos clientes da aplicação. Porém, se a aplicação começa a crescer, tendo que lidar com um grande número de usuários e com uma grande quantidade de dados para processar, não será suficiente apenas desenvolver o código e esperar que ele vá continuar funcionando sempre da mesma maneira, pois diversos problemas, como lentidão e indisponibilidade, podem começar a ocorrer.

Para lidar com o crescimento da aplicação, teremos que pensar em diversas estruturas para garantir que ela continue funcionando mesmo em condições muito mais complexas. Para isso, temos que pensar na Arquitetura de Software, que define a estrutura geral de um sistema para que ele consiga atender diversos requisitos que são comuns à grande maioria das aplicações, que são os requisitos não funcionais (ou atributos de qualidade).

Os requisitos não funcionais definem uma série de atributos que as aplicações devem atender para que ela tenha a qualidade esperada pelos seus usuários. Existe um grande número de requisitos não funcionais. Alguns dos mais conhecidos são o desempenho, a confiabilidade e a segurança. Uma aplicação que tenha um bom desempenho deve ser também escalável, isto é, continuar funcionando mesmo que o número de transações cresça. Uma aplicação também deve ser tolerante a falhas, não permitindo que uma falha cause uma indisponibilidade do serviço.

É praticamente impossível atingir todos os requisitos não funcionais de que uma aplicação necessita pensando apenas em código. Por isso, é essencial que desenvolvedores e desenvolvedoras saibam identificar implementações que podem causar problemas, seja de desempenho, de confiabilidade ou de segurança. Além disso, é essencial conhecer um grande número de ferramentas e tecnologias que podem ser usadas para evitar problemas, ou até para resolver um problema que talvez já esteja ocorrendo em uma aplicação.

Este livro tem o objetivo de apresentar e discutir a pessoas desenvolvedoras, sejam iniciantes ou já seniores, os principais requisitos não funcionais que devem ser pensados na hora de implementar uma aplicação. Entre esses requisitos estão o desempenho, a confiabilidade e a segurança. Dentro desses três requisitos, serão discutidos diversos outros que são derivados ou bastante relacionados a eles, como escalabilidade, disponibilidade, elasticidade, monitoramento, controle de acesso e tolerância a falhas. Além de discutir os requisitos não funcionais, também serão apresentadas diversas ferramentas para a implementação desses requisitos, como cache, balanceadores de carga e ferramentas de integração contínua.

Como este livro está organizado?

O livro tem dois objetivos principais: apresentar as arquiteturas de software mais utilizadas e discutir os principais requisitos não funcionais que devem ser considerados na maioria das aplicações. Para isso, este livro está organizado em cinco partes.

A Parte 1, Introdução à Arquitetura de Software, descreve algumas das arquiteturas de software mais utilizadas. Elas se dividem em dois tipos principais: os monólitos e as arquiteturas distribuídas. Dentro desses dois tipos existem diversas variações, como monólitos que são implementados usando a arquitetura em camadas, ou arquiteturas distribuídas que usam eventos ou microsserviços. Além de apresentar os tipos de arquitetura, também serão discutidas as vantagens e desvantagens de cada um dos modelos em relação aos requisitos não funcionais.

A Parte 2, Desempenho, apresentará formas para melhorar o desempenho da aplicação. Veremos diversos padrões e tecnologias que podem ajudar uma aplicação a alcançar um bom desempenho, como a utilização de caches e de algoritmos que possuem baixa complexidade de execução. Além disso, serão discutidos outros dois requisitos não funcionais que são bastante ligados ao desempenho: a escalabilidade e a elasticidade.

A Parte 3, Confiabilidade, mostrará ferramentas para deixar a aplicação mais confiável e evitar, ou pelo menos minimizar, os riscos de os usuários serem impactados com eventuais falhas do sistema. Também serão mostradas ferramentas para o monitoramento da aplicação, para que, quando uma falha acontecer, ela seja detectada o mais rápido possível.

A Parte 4, Segurança, focará na segurança das aplicações. Existem diversos padrões que devem ser seguidos, desde como os servidores devem ser expostos na internet, até como os dados dos usuários devem ser mantidos em bancos de dados para evitar riscos em uma aplicação. Serão apresentados alguns dos conceitos mais importantes para a segurança de aplicações, como o controle de acesso e o monitoramento de dependências.

Por fim, a Parte 5, Outros requisitos não funcionais, discutirá requisitos não funcionais como a usabilidade e a testabilidade, entre outros que também são bastante importantes, mas que não serão abordados com muita profundidade nas Partes 2, 3 e 4 por não serem tão ligados à arquitetura e à execução das aplicações.

Sobre o autor

Tenho quase 20 anos de experiência com Ciência da Computação, especialmente nas áreas de Engenharia de Software e Sistemas Distribuídos. Trabalhei principalmente com Java, tendo pego praticamente toda a evolução da plataforma, começando no Java 1.2 e agora já usando a versão 21. Também trabalhei com praticamente todos os principais frameworks dessa linguagem, como os já legados Struts e JSF e, atualmente, com Spring e Quarkus. Além do Java, já fiz bastante coisa em Python, JavaScript, Golang e Erlang.

Já trabalhei em diversas empresas, como o eBay e o Serasa; atualmente, sou Arquiteto de Software na BotCity. Fiz graduação e mestrado, em 2007 e 2010, respectivamente, na Universidade Federal de São Carlos (UFSCar) e doutorado na Universidade de São Paulo (USP) em 2019, trabalhando principalmente com Sistemas Distribuídos.

Se você quiser entrar em contato comigo, fique à vontade para me chamar no LinkedIn ou no GitHub:

https://www.linkedin.com/in/ezambomsantana/

https://github.com/ezambomsantana

Prefácio

Este livro é resultado dos quase 20 anos de trabalho com Engenharia de Software, alguns como desenvolvedor, outros como arquiteto, alguns também como professor, e todos como aluno desta área, tão importante na Ciência da Computação. Muitas das coisas que eu coloquei neste livro eu gostaria de ter aprendido há 15 anos, para utilizar em alguns projetos que participei. Com a experiência que tenho hoje, fica clara a falta de preocupação com diversas partes essenciais de uma aplicação, como com a sua confiabilidade e sua segurança.

Já trabalhei em projetos que eram excelentes produtos, que foram validados com os clientes e tinham tudo para ser um grande sucesso, mas que falharam, seja porque atingiram um número maior de clientes e não suportaram a carga, ou porque não eram confiáveis o suficiente. Alguns até funcionavam para os casos de uso básico para os quais foram projetados, mas qualquer coisa que fugia um pouco do padrão fazia a aplicação apresentar resultados inesperados.

Sem dúvida, os assuntos que este livro foca — desempenho, confiabilidade e segurança — são muito mais discutidos hoje do que eram quando eu comecei a trabalhar na área, e a quantidade de ferramentas e técnicas que existem hoje para conseguir implementar esses requisitos com sucesso é muito maior. Quem me dera que, há 10 anos, quando trabalhei em um projeto que tinha que atender uma fila de tickets de atendimento, já existisse o Apache Kafka.

Apesar da grande evolução que essa área teve nos últimos anos, a implementação desses requisitos é tão ou até mais desafiadora do que era quando eu comecei. Isso porque as aplicações hoje são maiores e mais complexas, possuem um número de usuários que pode ser muito maior e estão muito mais expostas na internet, o que faz os desafios de segurança serem muito maiores.

Espero que você aproveite a leitura e que os conhecimentos contidos neste livro sejam úteis para que a sua aplicação funcione com um bom desempenho e de forma confiável e segura.

— Eduardo Zambom

Parte 1: Introdução à Arquitetura de Software

Capítulo 1

Arquitetura de software

Existem diversos tipos de sistemas, desde aplicações muito simples, que possuem apenas cadastros simples, com alguns formulários e listagens de dados, até aplicações bastante complexas, que precisam processar milhares ou milhões de requisições em um curto período de tempo, fazendo integrações com outros sistemas e sincronizando diversas transações que acontecem paralelamente.

Em aplicações mais simples, pensar na arquitetura do software talvez não seja muito importante. Para uma simples aplicação web, talvez executá-la em um servidor na nuvem, desenvolvê-la em um monólito e implementá-la com acesso a um banco de dados relacional seja mais do que o suficiente para a execução com uma disponibilidade em praticamente 100% do tempo.

Em aplicações mais complexas, essa arquitetura simples descrita no parágrafo anterior pode até funcionar durante algum tempo, mas, com o crescimento do número de usuários ou com a inclusão de funcionalidades que demandem grande poder computacional, a aplicação pode começar a falhar. Isso pode acontecer porque os recursos computacionais usados não são suficientes para satisfazer a demanda que a aplicação necessita.

A primeira solução para resolver esse problema é simplesmente melhorar os recursos computacionais para a aplicação: aumentar a capacidade de processamento e a quantidade de memória disponível. Isso pode funcionar por algum tempo, mas logo os custos ficarão altos demais. Por isso, em aplicações mais complexas, é necessário projetar e implementar uma arquitetura mais robusta, para que a aplicação continue a ter um bom desempenho, uma alta disponibilidade e uma boa segurança, mesmo em condições adversas, e sem ter um custo extremamente alto, tanto para o desenvolvimento quanto para a sua execução.

A decisão de como fazer essas implementações necessárias para melhorar a execução das aplicações faz parte do que chamamos de arquitetura de software. Descrever exatamente o que é arquitetura de software é uma tarefa difícil. Até hoje não existe uma definição universalmente aceita para esse conceito. Duas bastante conhecidas são (ambas em tradução livre do original em inglês):

"Arquitetura de software é a estrutura fundamental de um sistema, incorporada em seus componentes, suas relações entre si e com o ambiente, e os princípios que governam seu projeto e evolução" (do documento 1471-2000 - IEEE Recommended Practice for Architectural Description for Software-Intensive Systems; IEEE, 2000);

"Arquitetura de software é o conjunto de estruturas necessárias para se pensar sobre o sistema, que compreende elementos de software, as relações entre eles e as propriedades de ambos" (do livro Documenting Software Architectures: Views and Beyond; CLEMENTS et al., 2010).

Note que essas definições focam bastante na descrição dos componentes da aplicação e de como eles se comunicam. A essas definições, eu adiciono que, além de definir os componentes e suas formas de comunicação, a arquitetura de software deve definir como a aplicação vai lidar com os principais requisitos não funcionais que ela precisa atender.

Na Engenharia de Software, os requisitos funcionais são as funcionalidades que a aplicação precisa implementar. Por exemplo, o cadastro e listagem de usuários e a realização de compras são requisitos que precisam ser implementados para que uma aplicação atenda ao que um usuário espera.

Porém, não adianta nada uma aplicação atender a todos os requisitos que o usuário deseja, mas o funcionamento dela não ser bom — o sistema demorar muito para responder uma chamada, ficar fora do ar por muito tempo ou ter uma interface muito complexa, que dificulta a utilização da aplicação. Esses atributos de qualidade, que são independentes da funcionalidade de um sistema, são chamados de requisitos não funcionais.

Alguns dos requisitos não funcionais mais importantes são:

Desempenho: a aplicação deve responder em um tempo que seja aceitável para o usuário. Por exemplo, uma página web não pode demorar mais do que alguns poucos segundos para carregar, senão o usuário ficará esperando por muito tempo;

Escalabilidade: normalmente, uma aplicação