Explorando a dualidade de Janus na arquitetura de microserviços: como utilizar o framework Spring Cloud Gateway para gerenciar a comunicação e balanceamento entre serviços de forma eficiente

Introdução

Na era dos microserviços, a comunicação entre as diversas partes de uma aplicação é crucial. O padrão de arquitetura Janus surge como uma solução eficaz, permitindo que sejam gerenciadas duas visões de um sistema: a de entrada e a de saída. Neste contexto, o Spring Cloud Gateway torna-se uma ferramenta essencial, facilitando o gerenciamento das comunicações e o balanceamento de carga entre os serviços. Este tutorial detalhado mostrará como configurar e utilizar o Spring Cloud Gateway em uma aplicação de microserviços, cobrindo desde a instalação até a configuração de rotas, filtros e balanceamento entre serviços, tudo com código acessível e direto.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de ter o JDK (Java Development Kit) e o Maven instalados em sua máquina. Verifique as versões instaladas usando os comandos `java -version` e `mvn -version`. Caso não os tenha instalados, siga as instruções oficiais nos sites das respectivas ferramentas.
commands
```
# Verificar versões instaladas
java -version
mvn -version
```

Criação do Projeto Spring Cloud Gateway

Utilize o Spring Initializr para gerar um novo projeto Spring Boot com as dependências necessárias. Escolha o seguinte: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Cloud Gateway’, ‘Spring Web’ e ‘Spring Boot DevTools’. Baixe e descompacte o projeto no seu ambiente de trabalho.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>gateway-service</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>gateway-service</name>
  <description>Spring Cloud Gateway Example</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

Criação de um Serviço Simulado

Para simular a comunicação entre microserviços, criaremos um serviço simples que o gateway irá encaminhar as requisições. Crie um novo projeto Spring Boot chamado ‘service-a’ seguindo os mesmos passos do passo 2, com as dependências ‘Spring Web’ e ‘Spring Boot DevTools’.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>service-a</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>service-a</name>
  <description>Serviço para Gateway</description>
  <properties>
    <java.version>11</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-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

Implementação do Controlador no Serviço A

Crie um controlador simples com um endpoint que retorne uma mensagem. Crie a classe `GreetingController` no pacote `com.example.servicea.controller`.

GreetingController.java

package com.example.servicea.controller;

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

@RestController
public class GreetingController {

    @GetMapping("/greeting")
    public String greet() {
        return "Hello from Service A!";
    }
}

Configuração do Spring Cloud Gateway

No projeto do gateway, crie o arquivo `application.yml` para definir as rotas do gateway. Este arquivo deve apontar para o serviço A que você criou anteriormente.

application.yml

spring:
  cloud:
    gateway:
      routes:
        - id: service-a
          uri: http://localhost:8081
          predicates:
            - Path=/service-a/**
          filters:
            - RewritePath=/service-a/(?<segment>.*), /greeting

Executando os Serviços
Utilize o Maven para compilar e executar ambos os projetos. Abra dois terminais: um para o gateway e outro para o serviço A. Execute os seguintes comandos em seus respectivos diretórios.
commands
```
# No terminal do gateway
mvn spring-boot:run
# No terminal do serviço A
mvn spring-boot:run
```
Testando a Comunicação via Gateway
Use uma ferramenta como Postman ou cURL para testar o endpoint do Gateway, que deve encaminhar a requisição para o serviço A. Execute o seguinte comando no terminal.
commands
```
# Testando o endpoint
curl -X GET http://localhost:8080/service-a/greeting
```
expected_response
```
Hello from Service A!
```

Implementação de Testes Unitários

Crie a classe de teste `GreetingControllerTest` para validar o controlador do serviço A.

GreetingControllerTest.java

package com.example.servicea.controller;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;

@SpringBootTest
@AutoConfigureMockMvc
public class GreetingControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGreet() throws Exception {
        mockMvc.perform(get("/greeting")
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello from Service A!"));
    }
}

Executando os Testes
Utilize o Maven para executar os testes do serviço A e garantir que tudo esteja funcionando conforme o esperado.
commands
```
# Executando os testes do serviço A
mvn test
```

Conclusão

Neste tutorial, exploramos a dualidade de Janus na arquitetura de microserviços utilizando o framework Spring Cloud Gateway. Implementamos um gateway para gerenciar a comunicação entre microserviços, testamos a configuração de rotas e garantimos a funcionalidade através de testes unitários. Ao final, você adquiriu conhecimento prático sobre como utilizar o Spring Cloud Gateway para simplificar e eficientizar as comunicações em suas aplicações de microserviços.

Hashtags

#SpringCloudGateway #Microservices #Java #SpringBoot #SoftwareArchitecture

copycoda.com.br