Gargalos

Para entregar uma aplicação de alto desempenho, você precisa identificar e tratar possíveis gargalos (bottlenecks) no seu sistema. Este documento apresenta alguns gargalos comuns e como mitigá-los.

Gargalo	Descrição	Mitigação
Caching	Armazenar em memória os dados acessados com frequência para reduzir a carga no banco de dados.	Use bancos de dados em memória como Redis ou Memcached.
Observabilidade	Monitorar o estado interno do sistema para identificar problemas de desempenho.	Use ferramentas como Prometheus e Grafana para monitoramento.
Mensageria	Desacoplar componentes para tratar tarefas assíncronas.	Use filas de mensagens como RabbitMQ ou Apache Kafka.
Balanceamento de carga	Distribuir o tráfego de entrada entre vários servidores para evitar sobrecarga.	Use balanceadores de carga como Nginx ou HAProxy.
Varredura de vulnerabilidades	Identificar e corrigir vulnerabilidades de segurança na aplicação.	Use ferramentas como SonarQube, OWASP ZAP ou Snyk para a varredura de vulnerabilidades.
Processamento de pagamentos	Tratar transações de pagamento de forma eficiente e segura.	Use gateways de pagamento de terceiros como Stripe ou PayPal e garanta a integração e o tratamento de erros adequados.
Autenticação e autorização	Gerenciar permissões de usuários e controle de acesso de forma eficiente.	Implemente controle de acesso baseado em papéis (RBAC). Ou use OAuth2 para autenticação baseada em token.

Caching

Bancos de dados em memória são uma ótima forma de melhorar o desempenho da sua aplicação. Eles podem ser usados para armazenar dados acessados com frequência, reduzindo a necessidade de consultar o banco de dados a cada requisição. Exemplos de bancos de dados em memória incluem Redis e Memcached.

Observabilidade

Observabilidade é a capacidade de medir e entender o estado interno de um sistema a partir das suas saídas externas. Ela é essencial para identificar e diagnosticar problemas de desempenho na sua aplicação. Ferramentas como Prometheus e Grafana ajudam a monitorar o desempenho da sua aplicação e a identificar gargalos.

Spring + Prometheus + Grafana

Esta dica apresenta uma configuração básica para integrar Spring Boot com Prometheus e Grafana para fins de monitoramento.

Estrutura de arquivos sugerida:

📁 microservice
├── 📁 src
│   └── 📁 main
│       └── 📁 resources
│           └──  application.yaml
└──  pom.xml
📁 volume
├── 📁 prometheus
│   └──  prometheus.yml
└── 📁 grafana
    └── 📁 provisioning
        └── 📁 datasources
            └──  datasources.yml
 .env # (1)!
 compose.yaml

VOLUME=./volume

1. pom.xml2. application.yaml3. compose.yaml4. prometheus.yml5. Grafana com Prometheus6. Acessar o Grafana

Adicione as seguintes dependências ao seu arquivo pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
    <scope>runtime</scope>
</dependency>

Configure o arquivo application.yaml para habilitar o actuator e o endpoint do Prometheus:

server:
  port: 8080

spring:
  application:
    name: gateway

management:
  endpoint:
    gateway:
      enabled: true
  endpoints:
    web:
      base-path: /gateway/actuator
      exposure:
        include: [ 'prometheus', 'gateway' ]

Inclua no arquivo compose.yaml a configuração do Prometheus e do Grafana:

name: store

services:

  prometheus:
    image: prom/prometheus:latest
    hostname: prometheus
    ports:
      - 9090:9090
    volumes:
      - $VOLUME/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana-enterprise
    hostname: grafana
    ports:
      - 3000:3000
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - $VOLUME/grafana:/var/lib/grafana
      - $VOLUME/grafana/provisioning/datasources:/etc/grafana/provisioning/datasources      
    restart: always
    depends_on:
      - prometheus

Conecte o Prometheus à sua aplicação Spring Boot criando um arquivo prometheus.yaml:

scrape_configs:

  - job_name: 'GatewayMetrics'
    metrics_path: '/gateway/actuator/prometheus'
    scrape_interval: 1s
    static_configs:
      - targets:
        - gateway:8080
        labels:
          application: 'Gateway Application'

  - job_name: 'AuthMetrics'
    metrics_path: '/auth/actuator/prometheus'
    scrape_interval: 1s
    static_configs:
      - targets:
        - auth:8080
        labels:
          application: 'Auth Application'

  # - job_name: 'AccountMetrics'
  #   metrics_path: '/account/actuator/prometheus'
  #   scrape_interval: 1s
  #   static_configs:
  #     - targets:
  #       - account:8080
  #       labels:
  #         application: 'Account Application'

  # - job_name: 'ProductMetrics'
  #   metrics_path: '/product/actuator/prometheus'
  #   scrape_interval: 1s
  #   static_configs:
  #     - targets:
  #       - product:8080
  #       labels:
  #         application: 'Product Application'

  # - job_name: 'OrderMetrics'
  #   metrics_path: '/order/actuator/prometheus'
  #   scrape_interval: 1s
  #   static_configs:
  #     - targets:
  #       - order:8080
  #       labels:
  #         application: 'Order Application'

Para conectar o Grafana ao Prometheus, crie um arquivo datasources.yml no diretório provisioning/datasources:

apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true

Depois de iniciar os containers e mapear as portas para a sua máquina local, você pode acessar o Grafana em http://localhost:3000 com o usuário padrão admin e a senha admin. Em seguida, você pode criar ou importar dashboards para visualizar as métricas coletadas da sua aplicação Spring Boot.

Para mais informações sobre como criar dashboards no Grafana, consulte a documentação do Grafana.

Um bom dashboard para Spring Boot

Você encontra um bom dashboard para aplicações Spring Boot no repositório de dashboards do Grafana: SpringBoot APM Dashboard.

Mensageria

Filas de mensagens são uma ótima forma de desacoplar sua aplicação e melhorar seu desempenho. Elas podem ser usadas para tratar tarefas assíncronas, como enviar e-mails ou processar tarefas em segundo plano. Exemplos de filas de mensagens incluem RabbitMQ e Apache Kafka.

Balanceamento de carga

Balanceamento de carga é o processo de distribuir o tráfego de rede de entrada entre vários servidores. Isso ajuda a garantir que nenhum servidor fique sobrecarregado de requisições, melhorando o desempenho geral e a confiabilidade da sua aplicação. Ferramentas como Nginx e HAProxy ajudam a implementar o balanceamento de carga na sua aplicação.

How To Configure Nginx as a Reverse Proxy on Ubuntu

Varredura de vulnerabilidades

A varredura de vulnerabilidades é o processo de identificar e corrigir vulnerabilidades de segurança na sua aplicação. Ferramentas como OWASP ZAP e Snyk ajudam a identificar possíveis problemas de segurança no seu código e nas suas dependências.

Entrega

Individualmente, cada aluno deve criar um repositório no GitHub, com a documentação em MkDocs dos exercícios realizados e também com o projeto e entregar o link via Blackboard. Na documentação publicada deve constar:

Nome do aluno e grupo;
Documentação das atividades realizadas;
Código fonte das atividades realizadas;
Documentação do projeto;
Código fonte do projeto;
Link para todos os repositórios utilizados;
Destaques para os bottlenecks implementados (ao menos 2 por indivíduo);
Apresentação do projeto;
Vídeo de apresentação do projeto (2-3 minutos);

Um template de documentação pode ser encontrado em Template de Documentação.