📚 Pré-requisitos Teóricos: este projeto aplica conceitos ensinados em Módulo 11: Qualidade e Testes de Software. Recomendado revisar antes de começar.

Guia do Projeto: Teste de Carga Visual (Java 21, Gatling, Grafana)

Método 1: Interface Web (start.spring.io)

1. Acesse https://start.spring.io
2. Configure o “Project Metadata” (Metadados do Projeto):
   • Project: Maven
   • Language: Java
   • Spring Boot: 3.3.0 (ou a versão estável mais recente que suporte Java 21)
   • Group: com.example
   • Artifact: servico-a (repita o processo com servico-b para o outro módulo)
   • Name: servico-a
   • Packaging: Jar
   • Java: 21
3. Adicione as Dependências (clique em “ADD DEPENDENCIES…“):
   • Spring Web: (Para criar controladores REST)
   • Spring Boot Actuator: (Para expor endpoints de gerenciamento, como /health e /metrics)
   • Prometheus: (Para formatar as métricas do Actuator para o Prometheus)
4. Clique em “GENERATE”.
5. Extraia o arquivo .zip baixado. Esta é a estrutura base do seu projeto.

Método 2: Linha de Comando (cURL)

Este método é ideal para automação e evita a interface gráfica.

Para o servico-a

Execute o seguinte comando no seu terminal. Ele baixa e descompacta o projeto.

# Baixa o .zip
curl https://start.spring.io/starter.zip \
    -d type=maven-project \
    -d language=java \
    -d platformVersion=3.3.0 \
    -d javaVersion=21 \
    -d groupId=com.example \
    -d artifactId=servico-a \
    -d name=servico-a \
    -d packaging=jar \
    -d dependencies=web,actuator,prometheus \
    -o servico-a.zip

# Descompacta
unzip servico-a.zip -d servico-a
rm servico-a.zip

Para o servico-b

# Baixa o .zip
curl https://start.spring.io/starter.zip \
    -d type=maven-project \
    -d language=java \
    -d platformVersion=3.3.0 \
    -d javaVersion=21 \
    -d groupId=com.example \
    -d artifactId=servico-b \
    -d name=servico-b \
    -d packaging=jar \
    -d dependencies=web,actuator,prometheus \
    -o servico-b.zip

# Descompacta
unzip servico-b.zip -d servico-b
rm servico-b.zip

Método 3: Dentro da IDE

IntelliJ IDEA (Ultimate Edition)

1. Vá em File > New > Project....
2. Selecione Spring Initializr no painel esquerdo.
3. Preencha os metadados:
   • Name: servico-a
   • Location: (Escolha o diretório pai)
   • Language: Java
   • Type: Maven
   • Group: com.example
   • Package name: com.example.servicoa
   • Java Version: SDK 21
4. Clique em Next.
5. Na tela de dependências, selecione a versão do Spring Boot (ex: 3.3.0) e procure por:
   • Web: Spring Web
   • Ops: Spring Boot Actuator
   • Observability: Prometheus
6. Clique em Create.

Visual Studio Code (com o “Spring Initializr Java Support” do Extension Pack for Java)

1. Abra a paleta de comandos: Ctrl+Shift+P (Windows/Linux) ou Cmd+Shift+P (macOS).
2. Digite e selecione Spring Initializr: Create a Maven Project....
3. Selecione a versão do Spring Boot (ex: 3.3.0).
4. Selecione a linguagem: Java.
5. Digite o Group ID: com.example.
6. Digite o Artifact ID: servico-a.
7. Selecione o tipo de empacotamento: Jar.
8. Selecione a versão do Java: 21.
9. Procure e marque as dependências (pressione Enter após selecionar):
   • Spring Web
   • Spring Boot Actuator
   • Prometheus
10. Escolha o local para gerar o projeto.

projeto-teste-carga/
├── .gitignore
├── docker-compose.yml       <-- (Módulo 2: Orquestrador do Prometheus e Grafana)
├── prometheus.yml           <-- (Módulo 2: Configuração de scrape do Prometheus)
|
├── servico-a/               <-- (Módulo 1: Spring Boot API de Pedidos)
│   ├── .mvn/
│   ├── mvnw
│   ├── mvnw.cmd
│   ├── pom.xml              <-- (Dependências: Web, Actuator, Prometheus)
│   └── src/
│       ├── main/
│       │   ├── java/
│       │   │   └── com/
│       │   │       └── example/
│       │   │           └── servicoa/
│       │   │               ├── PedidoController.java
│       │   │               └── ServicoAApplication.java
│       │   └── resources/
│       │       └── application.properties  <-- (server.port=8081)
│       └── test/
│           └── ...
│
├── servico-b/               <-- (Módulo 1: Spring Boot API de Estoque)
│   ├── .mvn/
│   ├── mvnw
│   ├── mvnw.cmd
│   ├── pom.xml              <-- (Dependências: Web, Actuator, Prometheus)
│   └── src/
│       ├── main/
│       │   ├── java/
│       │   │   └── com/
│       │   │       └── example/
│       │   │           └── servicob/
│       │   │               ├── EstoqueController.java
│       │   │               └── ServicoBApplication.java
│       │   └── resources/
│       │       └── application.properties  <-- (server.port=8082)
│       └── test/
│           └── ...
│
└── gatling-teste/           <-- (Módulo 3: Projeto de Teste de Carga)
    ├── .mvn/
    ├── mvnw
    ├── mvnw.cmd
    ├── pom.xml              <-- (Dependências do Gatling, ex: gatling-maven-plugin)
    └── src/
        └── test/
            ├── resources/
            │   └── gatling.conf  <-- (Configurações opcionais do Gatling)
            └── scala/
                └── simulations/
                    └── CargaApiSimulation.scala  <-- (Script do teste de carga)

Este guia detalha a criação de um ambiente para testes de carga visuais em tempo real, monitorando a latência e a taxa de transferência entre dois microsserviços Spring Boot (Java 21).

1. Arquitetura Alvo

Utilizaremos uma arquitetura desacoplada para simular um cenário real. O Gatling ataca o servico-a, que por sua vez depende do servico-b. O Prometheus coleta métricas de ambos os serviços, e o Grafana exibe o dashboard.

flowchart TD
    subgraph "Ferramentas"
    Gatling("Gatling Engine")
    Grafana("Grafana Dashboard")
    Prometheus("Prometheus Scraper")
    end
    subgraph "Backend (Java 21 / Spring Boot)"
    SvcA["Serviço A: Pedidos<br/>(Porta: 8081)"]
    SvcB["Serviço B: Estoque<br/>(Porta: 8082)"]
    end
    Gatling -- 1. Carga HTTP (Usuários Virtuais) --> SvcA
    SvcA -- 2. Chamada REST interna --> SvcB
    Prometheus -- 3. Scrape (métricas) --> SvcA
    Prometheus -- 3. Scrape (métricas) --> SvcB
    Grafana -- 4. Query (PromQL) --> Prometheus

2. Módulo 1: Microsserviços Alvo (Java 21 / Spring Boot)

Criaremos dois serviços. Ambos devem ter as mesmas dependências do Micrometer para expor métricas ao Prometheus.

2.1. Dependências Maven (pom.xml)

Adicione a todos os serviços:

<properties>
    <java.version>21</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <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>
</dependencies>

2.2. Configuração (application.properties)

Serviço B (Estoque): servico-b/src/main/resources/application.properties

# Porta do Serviço B
server.port=8082
# Nome da Aplicação (para métricas)
spring.application.name=servico-b

# Ativa Virtual Threads (Java 21+)
spring.threads.virtual.enabled=true

# Expor o endpoint /actuator/prometheus
management.endpoints.web.exposure.include=prometheus,health
management.endpoint.health.show-details=always

Serviço A (Pedidos): servico-a/src/main/resources/application.properties

# Porta do Serviço A
server.port=8081
# Nome da Aplicação (para métricas)
spring.application.name=servico-a

# Ativa Virtual Threads (Java 21+)
spring.threads.virtual.enabled=true

# Expor o endpoint /actuator/prometheus
management.endpoints.web.exposure.include=prometheus,health
management.endpoint.health.show-details=always

# URL do serviço dependente
app.servico-b.url=http://localhost:8082

2.3. Código: Serviço B (Estoque)

Simula uma operação custosa (ex: consulta em banco de dados) com um atraso.

// servico-b/src/main/java/com/example/servicob/EstoqueController.java
package com.example.servicob;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

@RestController
public class EstoqueController {

    @GetMapping("/estoque/{produtoId}")
    public String getEstoque(@PathVariable String produtoId) {
        try {
            // Simula latência variável (ex: I/O de banco)
            long delay = ThreadLocalRandom.current().nextLong(50, 200);
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Produto " + produtoId + ": 10 unidades";
    }
}

2.4. Código: Serviço A (Pedidos)

Chama o Serviço B usando RestTemplate (ou WebClient).

// servico-a/src/main/java/com/example/servicoa/PedidoController.java
package com.example.servicoa;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Random;

@RestController
public class PedidoController {

    private final RestTemplate restTemplate;
    private final String servicoBUrl;

    public PedidoController(RestTemplateBuilder builder, @Value("${app.servico-b.url}") String servicoBUrl) {
        this.restTemplate = builder.build();
        this.servicoBUrl = servicoBUrl;
    }

    // Endpoint principal que será testado pelo Gatling
    @GetMapping("/fazer-pedido")
    public String fazerPedido() {
        // Simula a busca por um produto aleatório
        int produtoId = new Random().nextInt(1000);
        
        // Chama o Serviço B
        String estoqueInfo = restTemplate.getForObject(
                servicoBUrl + "/estoque/" + produtoId,
                String.class
        );

        return "Pedido criado. Info: " + estoqueInfo;
    }
}

3. Módulo 2: Pilha de Observabilidade (Docker)

Usaremos Docker Compose para subir o Prometheus e o Grafana.

3.1. Configuração Prometheus (prometheus.yml)

Crie este arquivo na raiz do projeto. Ele instrui o Prometheus a “raspar” (scrape) as métricas dos endpoints /actuator/prometheus dos nossos serviços.

# prometheus.yml
global:
  scrape_interval: 10s # Intervalo de coleta

scrape_configs:
  # Coleta métricas do Serviço A (Pedidos)
  - job_name: 'servico-a'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['host.docker.internal:8081'] # 'host.docker.internal' permite ao Docker acessar o host local

  # Coleta métricas do Serviço B (Estoque)
  - job_name: 'servico-b'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['host.docker.internal:8082']

3.2. Docker Compose (docker-compose.yml)

Este arquivo orquestra a pilha de monitoramento.

# docker-compose.yml
version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    # Permite que o container acesse os serviços no host
    extra_hosts:
      - "host.docker.internal:host-gateway" 

  grafana:
    image: grafana/grafana-oss:latest
    container_name: grafana
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
    environment:
      # Define o usuário/senha padrão
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin

4. Módulo 3: Teste de Carga (Gatling)

4.1. Estrutura do Projeto Gatling

Gatling usa Scala. A estrutura de pastas deve ser:

gatling-teste/
  src/
    test/
      scala/
        simulations/
          CargaApiSimulation.scala  <-- Nosso script de teste

4.2. Script de Simulação (Gatling)

Este script simula 100 usuários acessando o endpoint /fazer-pedido simultaneamente por 30 segundos.

// CargaApiSimulation.scala
package simulations

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class CargaApiSimulation extends Simulation {

  // 1. Configuração do Protocolo HTTP
  val httpProtocol = http
    .baseUrl("http://localhost:8081") // URL base do Serviço A
    .acceptHeader("application/json")
    .userAgentHeader("Gatling Load Test")

  // 2. Definição do Cenário
  val scn = scenario("Cenário de Carga API Pedidos")
    .exec(
      http("Req: Fazer Pedido")
        .get("/fazer-pedido")
        .check(status.is(200)) // Verifica se a resposta é HTTP 200
    )

  // 3. Configuração da Carga (Injeção de Usuários)
  setUp(
    scn.inject(
      // rampUsersPerSec(10).to(100).during(10.seconds), // Rampa de subida
      // nothingFor(5.seconds), // Pausa
      constantUsersPerSec(100).during(30.seconds) // Carga constante
    )
  ).protocols(httpProtocol)
}

5. Módulo 4: Execução e Análise Visual

5.1. Passo 1: Iniciar os Serviços Java

Inicie ambos os serviços Spring Boot (em terminais separados ou pela IDE):

# Terminal 1: Iniciar Serviço B (Estoque)
cd servico-b/
./mvnw spring-boot:run

# Terminal 2: Iniciar Serviço A (Pedidos)
cd servico-a/
./mvnw spring-boot:run

Verificação: Acesse http://localhost:8081/actuator/prometheus e http://localhost:8082/actuator/prometheus. Você deve ver as métricas.

5.2. Passo 2: Iniciar a Pilha de Monitoramento

# Terminal 3: Iniciar Prometheus e Grafana
docker-compose up

Verificação:

• Acesse http://localhost:9090 (Prometheus).
• Acesse http://localhost:3000 (Grafana). Login: admin/admin.

5.3. Passo 3: Configurar o Grafana

1. Acesse o Grafana (http://localhost:3000).
2. Vá para Connections -> Data sources -> Add new data source.
3. Selecione Prometheus.
4. No campo “Prometheus server URL”, insira: http://prometheus:9090 (Grafana e Prometheus estão na mesma rede Docker).
5. Clique em Save & Test.

5.4. Passo 4: Criar o Dashboard de Análise

1. Vá em Dashboards -> New -> New Dashboard.
2. Clique em Add visualization.
3. Selecione o Data Source Prometheus.

Painel 1: Taxa de Requisições (RPS) no Serviço A

Use a query PromQL para medir a taxa de requisições HTTP no servico-a.

// Mede a taxa de requisições por segundo (RPS) no endpoint /fazer-pedido
rate(http_server_requests_seconds_count{job="servico-a", uri="/fazer-pedido"}[1m])

Painel 2: Latência P95 (Serviço A vs Serviço B)

Use esta query para ver a latência (percentil 95) das chamadas.

// Latência P95 do endpoint /fazer-pedido (visão do Svc A)
histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket{job="servico-a", uri="/fazer-pedido"}[1m])) by (le))

// Latência P95 da chamada interna (visão do Svc B)
histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket{job="servico-b", uri="/estoque/{produtoId}"}[1m])) by (le))

Painel 3: Requisições com Erro (HTTP 5xx)

// Taxa de erros 5xx no Serviço A
rate(http_server_requests_seconds_count{job="servico-a", status=~"5.*"}[1m])

5.5. Passo 5: Executar o Gatling e Observar

1. Execute o Gatling (usando o Maven ou o script gatling.sh).

# Terminal 4: Executar o Teste
cd gatling-teste/
# Se estiver usando o plugin Maven do Gatling
./mvnw gatling:test -Dgatling.simulationClass=simulations.CargaApiSimulation

1. Enquanto o Gatling executa, observe o dashboard do Grafana (http://localhost:3000). Você verá os gráficos de RPS subindo, a latência aumentando e, eventualmente, erros (se o sistema não suportar a carga).

Voltar para Projetos

🚀 Como Executar no Laboratório

1. Abra o terminal na pasta deste projeto

No seu editor/IDE, abra a pasta deste projeto (File > Open Folder) ou navegue via terminal:

cd infra_nginx_03_gatling

2. Execute a aplicação ou testes

terraform init && terraform plan
# ou docker-compose up -d

[!TIP] Dica para execução a partir da raiz do repositório: Se você abriu o repositório completo no VS Code, basta navegar até a pasta antes de executar: cd catalogo_projetos/infra_nginx_03_gatling

🏛️ Arquitetura Visual & Engenharia de Infraestrutura

O diagrama abaixo ilustra a topologia de componentes, balanceamento, esteiras de automação e observabilidade na subpasta gatling-teste/:

flowchart TD
    subgraph Config["Configuração & IaC"]
        C1["Manifestos Declarativos"] --> C2["Variáveis & Segredos"]
    end
    subgraph Orquestracao["Orquestração & Redes"]
        O1["Load Balancer / Ingress"] --> O2["Pods / Contêineres de Serviço"]
    end
    subgraph Observabilidade["Observabilidade & Segurança"]
        M1["Telemetria Prometheus / k6"] --> M2["Scanners SAST & Dashboards"]
    end
    subgraph Qualidade["Homologação & Qualidade"]
        Q1["Automação CI/CD"] --> Q2["Checkpoints CP-01..05 PASS"]
    end

    Config --> Orquestracao
    Orquestracao --> Observabilidade
    Observabilidade --> Qualidade

    style Config fill:#e3f2fd,stroke:#1976d2,stroke-width:1.5px
    style Orquestracao fill:#fffde7,stroke:#fbc02d,stroke-width:1.5px
    style Observabilidade fill:#e8f5e9,stroke:#388e3c,stroke-width:1.5px
    style Qualidade fill:#f3e5f5,stroke:#7b1fa2,stroke-width:1.5px

🎯 Engenharia de Requisitos & Modelagem Formal

👤 User Stories (Histórias de Usuário)

⚙️ Requisitos Funcionais (RF)

🛡️ Requisitos Não-Funcionais (RNF)

🔗 Matriz de Rastreabilidade (RTM)

🏁 Checkpoints de Qualidade & Homologação