Gargalos

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

Gargalo	Descrição	Mitigação
Cache	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 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 integração e 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.

Cache

Bancos de dados em memória são uma ótima forma de melhorar o desempenho da sua aplicação. Eles podem armazenar os 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 de 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 aplicação e a identificar gargalos.

Spring + Prometheus + Grafana

Esta dica traz uma configuração básica para integrar o 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 subir 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, crie ou importe dashboards para visualizar as métricas coletadas da sua aplicação Spring Boot.

Para saber mais 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 a sua aplicação e melhorar o desempenho dela. Elas podem tratar tarefas assíncronas, como enviar e-mails ou processar jobs 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 garante 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

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.