a. Visão geral

A principal funcionalidade do microsserviço Gateway é rotear as requisições recebidas para o microsserviço apropriado; portanto, ele é o ponto de entrada de todas as requisições. Sem ele, cada microsserviço teria de expor a sua própria porta e os seus endpoints para a internet, o que não é uma boa prática. O microsserviço Gateway atua como um proxy reverso e roteia as requisições recebidas para o microsserviço apropriado. Além disso, ele também trata a autenticação e a autorização das requisições recebidas.

flowchart LR
    subgraph api [Camada confiável]
        gateway e2@==> account
        gateway e4@==> others
        account --> db@{ shape: cyl, label: "Banco de dados" }
        others --> db
    end
    internet e1@==>|requisição| gateway:::red
    e1@{ animate: true }
    e2@{ animate: true }
    e4@{ animate: true }
    classDef red fill:#fcc

Vantagens de usar um microsserviço Gateway:

Ele oferece um ponto de entrada único para todas as requisições, o que facilita gerenciar e proteger a aplicação;
Apenas uma porta precisa ser exposta para a internet, o que facilita proteger a aplicação;
Ele pode tratar:
- A autenticação e a autorização das requisições recebidas, o que facilita proteger a aplicação;
- O balanceamento de carga das requisições recebidas, o que facilita escalar a aplicação;
- O cache das requisições recebidas, o que ajuda a melhorar o desempenho da aplicação;
- O log e o monitoramento das requisições recebidas, o que facilita depurar e investigar problemas na aplicação;
- A limitação de taxa (rate limiting) das requisições recebidas, o que ajuda a proteger a aplicação contra ataques DDoS;

As funcionalidades-chave do microsserviço Gateway são:

Roteamento: ele roteia as requisições recebidas para o microsserviço apropriado.
Autenticação/Autorização: ele trata a autenticação e a autorização das requisições recebidas.

Gateway-Service

📁 api
├── 📁 gateway-service/
│   ├── 📁 src/
│   │   └── 📁 main/
│   │       ├── 📁 java/
│   │       │   └── 📁 store/
│   │       │       └── 📁 gateway/
│   │       │           ├──  GatewayApplication.java
│   │       │           └──  GatewayResource.java
│   │       └── 📁 resources/
│   │           └──  application.yaml
│   ├──  pom.xml
│   └──  Dockerfile
├──  .env
└──  compose.yaml

Código-fonte

pom.xmlapplication.yamlGatewayApplication.javaGatewayResource.javaDockerfile

<?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>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.0.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>store</groupId>
    <artifactId>gateway-service</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>25</java.version>
        <spring-cloud.version>2025.1.0</spring-cloud.version>
        <maven.compiler.proc>full</maven.compiler.proc>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway-server-webflux</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

spring:
  application:
    name: gateway

  cloud:
    gateway:
      server:
        webflux:

          globalcors:
            corsConfigurations:
              '[/**]':
                allowedOrigins: ${CORS_ALLOWED_ORIGINS:*}
                allowedHeaders: "*"
                allowedMethods: "*"

          routes:

            - id: insper
              uri: https://www.insper.edu.br
              predicates:
                - Path=/insper/**

            - id: accounts
              uri: http://account:8080 # hostname da maquina
              predicates:
                - Path=/accounts/**

package store.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewayApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }

}

package store.gateway;

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

@RestController
public class GatewayResource {

    @GetMapping("/")
    public ResponseEntity<String> hello() {
        return ResponseEntity.ok("Store API");
    }

    @GetMapping("/health-check")
    public ResponseEntity<Void> healthCheck() {
        return ResponseEntity.ok().build();
    }

}

FROM eclipse-temurin:25
VOLUME /tmp
COPY target/*.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Observe que o microsserviço Gateway é implementado com o Spring Cloud Gateway, uma biblioteca que oferece uma forma simples e eficaz de rotear as requisições recebidas para o microsserviço apropriado. Ela também oferece muitos recursos, como autenticação, autorização, balanceamento de carga, cache, log, monitoramento e limitação de taxa.

Além disso, o microsserviço Gateway é implementado com o WebFlux, um modelo de programação reativa que permite tratar um grande número de requisições concorrentes com um número pequeno de threads. Isso facilita escalar a aplicação e melhorar o seu desempenho.

application.yaml

O arquivo application.yaml está configurado para rotear as requisições recebidas para o microsserviço apropriado; portanto, você precisa garantir que os microsserviços estejam em execução e expondo as suas portas antes de iniciar o microsserviço Gateway.

Além disso, o arquivo application.yaml configura o CORS para permitir as requisições vindas da internet; portanto, você precisa garantir que a configuração de CORS esteja correta antes de iniciar o microsserviço Gateway.

Depois de terminar a implementação do microsserviço Gateway, podemos incluí-lo no arquivo compose.yaml e iniciá-lo com o Docker Compose. Você também pode testar o microsserviço Gateway enviando requisições para a porta exposta por ele e verificando se as requisições são roteadas para o microsserviço apropriado.

compose.yaml
name: store

services:

  db:
    image: postgres:17
    hostname: db
    ports:
      - 5432:5432
    volumes:
      - ${VOLUME_DB}:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: ${DB_USER:-store}
      POSTGRES_PASSWORD: ${DB_PASSWORD:-devpass}
      POSTGRES_DB: ${DB_NAME:-store}

  account:
    build:
      context: ./account-service
      dockerfile: Dockerfile
    hostname: account
    environment:
      DATABASE_HOST: db
      DATABASE_PORT: 5432
      DATABASE_DB: ${DB_NAME:-store}
      DATABASE_USERNAME: ${DB_USER:-store}
      DATABASE_PASSWORD: ${DB_PASSWORD:-devpass}
    deploy:
      replicas: 2
    depends_on:
      - db

  gateway:
    build:
      context: ./gateway-service
      dockerfile: Dockerfile
    hostname: gateway
    ports:
      - 8080:8080

Observe que os outros microsserviços declarados no arquivo compose.yaml não têm as suas portas expostas para a internet; portanto, eles só podem ser acessados por meio do microsserviço Gateway.