Forem: Marcelo Mendes

Criando service discovery com spring cloud gateway e eureka

Marcelo Mendes — Mon, 10 Feb 2025 16:31:15 +0000

Criando Service Discovery com Spring Cloud Gateway e Netflix Eureka

Marcelo Mendes — Mon, 10 Feb 2025 00:41:04 +0000

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.

Rodamos o Eureka Server
Rodamos as APIs (api-01 e api-02)
Rodamos o API Gateway
Verificamos o Eureka Server (http://localhost:8761)
- As APIs devem aparecer como registradas.
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! 🚀

Reflections em Java: Uma Ferramenta Poderosa

Marcelo Mendes — Fri, 20 Dec 2024 23:41:05 +0000

Vamos explorar o que é Reflections, seus usos e riscos, e como aplicá-lo na prática.

O que é Reflection?

Reflection é uma funcionalidade do Java que permite que o código inspecione e manipule classes, campos, métodos e construtores de objetos, mesmo que sejam privados ou desconhecidos em tempo de compilação.

Essa habilidade é muito boa para cenários dinâmicos, como ferramentas que interagem com classes desconhecidas ou que dependem de comportamento fora do default. Porém, Reflection deve ser usada com cuidado devido a seus impactos em desempenho e segurança.

Quando usar Reflection?

Frameworks e libs

Muitas libs utilizam Reflection para automatizar tarefas. Por exemplo, o JUnit usa Reflection para localizar e executar métodos de teste automaticamente.

Interoperabilidade e extensibilidade

Quando você precisa trabalhar com tipos desconhecidos em tempo de compilação. Um exemplo comum é carregar dinamicamente classes em um sistema modular.

Manipulação de objetos externos ou desconhecidos

É útil para acessar métodos ou campos de classes de terceiros que não possuem uma API pública.

Criação de ferramentas e depuração

Reflection é frequentemente usada em ferramentas como depuradores, analisadores de código e geradores de código dinâmico.

Cuidados ao usar Reflection

Reflection é poderosa, mas traz riscos porque pode quebrar algumas garantias fornecidas pelo compilador e pelo runtime no uso default. Aqui estão os principais riscos:

Quebra de encapsulamento

Reflection permite acessar campos e métodos private ou protected, ignorando os modificadores de acesso.

Erros em tempo de execução

Ao contrário do uso tradicional, erros de tipos ou métodos inexistentes só aparecem em tempo de execução, isso dificulta a depuração e os testes.

Impacto no desempenho

Métodos refletivos, como Method.invoke, têm um overhead maior porque bypassam as ações do compilador. Esse impacto pode ser significativo em aplicações com chamadas frequentes ou alta performance.

Ferramentas principais da classe Reflection

O pacote java.lang.reflect oferece várias classes e métodos que tornam possível manipular dinamicamente os elementos de uma classe. Aqui estão algumas das ferramentas mais importantes:

Class: O ponto de partida

A classe Class é usada para obter informações e manipular classes. É frequentemente a porta de entrada para outras operações de Reflection.

Métodos úteis:

getDeclaredFields(): Retorna todos os campos declarados na classe.
getDeclaredMethods(): Retorna todos os métodos declarados na classe.
getDeclaredConstructors(): Retorna todos os construtores declarados na classe.
getSuperclass(): Obtém a superclasse da classe.
getInterfaces(): Retorna as interfaces implementadas pela classe.

Na prática

Suponha que você tenha a seguinte entidade Weather (faltou os getters rs):

Essa entidade é um cron atualizada que faz chamadas a uma API externa e salva as temperaturas. Seu objetivo é buscar dinamicamente a temperatura de uma cidade. Veja como fazer isso usando Reflection:

Fluxo

Construção do Nome do Método:

O nome do método é criado dinamicamente concatenando "get" com o nome da cidade e "Temperature".

Obtenção do Método:

Usamos getDeclaredMethod para obter o método correspondente, que nesse caso são os getters.

Invocação do Método:

O método é invocado dinamicamente com invoke, retornando a temperatura.

Conclusão

Nesse artigo eu espero que vocês consigam entender de modo geral como essa ferramenta funcina no ecossistema Java, permitindo resolver problemas dinâmicos de maneira diferente. Porém, devido à quebra de encapsulamento, impacto no desempenho e dificuldade de depuração, deve ser usada com cuidado.
Entender os cenários adequados para aplicá-la e conhecer seus riscos é essencial para tirar o melhor proveito dessa funcionalidade sem comprometer a manutenção e a segurança do código.