Criando Service Discovery com Spring Cloud Gateway e Netflix Eureka

Introdução

Nesse artigo, vamos explorar dois patterns amplamente utilizados em arquiteturas de microsserviços: Service Discovery e API Gateway. Veremos suas utilidades, benefícios e como implementá-los utilizando Spring Cloud Gateway e Eureka Server.

O que é um Service Discovery?

Em um ambiente de microsserviços, um cliente pode precisar se comunicar com diversas APIs que rodam em diferentes portas e servidores. Mas o cliente geralmente não sabe os endereços exatos dessas APIs.

Imagine o seguinte cenário:

Se não houver alguma forma para descobrir automaticamente os serviços disponíveis, precisaríamos gerenciar manualmente os endereços de cada API. Isso torna a manutenção do sistema mais complexa e suscetível a erros.

É aí que entra o Service Discovery. Ele age como uma espécie de banco de registro, onde as aplicações ao subirem, se registram nele permitindo que os clientes descubram automaticamente onde eles estão rodando. No ecossistema do Spring, utilizamos o Eureka Server para essa funcionalidade.

Quando as aplicações são iniciadas, elas se registram no Eureka Server. Assim, qualquer cliente pode consultar o Eureka e descobrir quais serviços estão disponíveis e onde eles estão rodando.

Com essa abordagem, o API Gateway pode atuar apenas como um roteador, passando para o Eureka a responsabilidade de gerenciar os registros dos serviços:

Implementação

Agora, vamos implementar um Gateway que busca os serviços registrados no Eureka Server. O código completo deste projeto está disponível no repositório no final do artigo.

Criando o Eureka Server

O primeiro passo é criar um projeto Spring Boot. Eu utilizei o Spring Initializr mas faça como preferir. Selecionando a dependência Eureka Server.

Após criar o projeto, abra-o na sua IDE e adicione as seguintes configurações no arquivo application.properties:

server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

• server.port=8761: Define a porta padrão do Eureka Server.
• eureka.client.register-with-eureka=false: Como este é o servidor do Eureka, ele não precisa se registrar nele mesmo.
• eureka.client.fetch-registry=false: Ele não precisa buscar registros, apenas fornecer informações aos clientes.

Agora, no arquivo ServiceDiscoveryApplication, adicionamos a anotação @EnableEurekaServer:

@SpringBootApplication
@EnableEurekaServer
public class ServiceDiscoveryApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceDiscoveryApplication.class, args);
    }
}

Agora, ao rodar o projeto, conseguimos visualizar a interface do Eureka Server acessando http://localhost:8761:

Por enquanto não temos nenhum serviço no registro porque não subimos nenhuma API no Eureka Server.

Criando Serviços Cliente (API-01 e API-02)

Vamos criar duas APIs simples (api-01 e api-02) que serão registradas no Eureka. Para isso, utilizamos o Spring Initializr, adicionando as dependências:

• Eureka Client (para registro no Eureka Server)
• Spring Web (para expor endpoints)

Configurações

No application.properties de cada API, adicionamos:

server.port=8181  # Ou outra porta para a segunda API
eureka.client.service-url.default-zone=http://localhost:8761/eureka/
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

Criando um endpoint de teste

Agora, criamos um controlador simples para expor um endpoint:

@RestController
@RequestMapping("/api")
public class HealthCheckController {
    @GetMapping("/health")
    public String healthCheck() {
        return "API-01 está saudável!";
    }
}

Com isso, ao rodarmos as APIs, elas se registrarão automaticamente no Eureka Server.

Note que na imagem temos o gateway exposto também, ele será implementado no próximo passo.

Bom, já criamos o Eureka Server, a api-01 e a api-02. Elas já estão rodando, registradas e podem buscar informações no nosso serviço de descoberta. Agora temos algo parecido com um livro de endereços, onde conseguimos acessar as informações das APIs sem precisar lembrar de cada endereço e porta manualmente.
Mas ainda falta algo. A gente não quer que o cliente precise saber os endereços específicos de cada API, certo? Para resolver isso, usamos um gateway. Ele vai consultar o registro de serviços e passar um único ponto de acesso para os clientes, garantindo que todas as requisições entre microsserviços sejam roteadas de forma transparente.

Criando o API Gateway

O próximo passo é criar o Spring Cloud Gateway, que será responsável por rotear as requisições para os serviços registrados no Eureka.

No Spring Initializr, adicionamos as dependências:

• Spring Cloud Gateway
• Eureka Client

Configurações do Gateway

No application.properties, adicionamos:

eureka.client.service-url.default-zone=http://localhost:8761/eureka/
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

spring.cloud.gateway.discovery.locator.enabled=true
spring.cloud.gateway.discovery.locator.lower-case-service-id=true

• spring.cloud.gateway.discovery.locator.enabled=true: Permite que o Gateway descubra automaticamente os serviços registrados no Eureka.
• spring.cloud.gateway.discovery.locator.lower-case-service-id=true: Garante que os nomes das aplicações sejam tratados em letras minúsculas, tornando as requisições mais legíveis.

Testando a Comunicação

Agora que o Gateway e os serviços estão configurados, podemos testar a comunicação.

1. Rodamos o Eureka Server
2. Rodamos as APIs (api-01 e api-02)
3. Rodamos o API Gateway
4. Verificamos o Eureka Server (http://localhost:8761)
   • As APIs devem aparecer como registradas.
5. Testamos o roteamento
   • http://localhost:8080/api-01/api/health → Deve retornar: API-01 está saudável!
   • http://localhost:8080/api-02/api/health → Deve retornar: API-02 está saudável!

O Gateway está funcionando corretamente, roteando as requisições para os serviços automaticamente!

Conclusão

Com essa implementação, conseguimos:

✅ Criar um Eureka Server para gerenciar o registro de serviços.
✅ Criar APIs clientes que se registram automaticamente no Eureka.
✅ Configurar um API Gateway que roteia as requisições sem necessidade de mapear manualmente os endpoints.
✅ Facilitar a escalabilidade e manutenção dos serviços.

Essa abordagem reduz o acoplamento entre os serviços e facilita a comunicação dinâmica entre microsserviços.

📌 O código completo do projeto pode ser acessado aqui (https://github.com/Marcelovmendes/service-discovery).

Gostou do artigo? Compartilhe e deixe seu comentário! 🚀