Nathalia Amaral – Blog

Como configurar circuit breaker com openfeign e resilience4j

Se você está desenvolvendo um microserviço com Spring Boot e precisa se comunicar com outros serviços via HTTP, o OpenFeign é uma excelente escolha. Ele simplifica a criação de clientes HTTP declarativos. Além disso, quando estamos lidando com comunicação entre serviços, é essencial implementar padrões de tolerância a falhas, como o Circuit Breaker. Para isso, o Resilience4J é uma biblioteca robusta que pode ser facilmente integrada ao Spring Boot.

Neste post, vamos configurar e utilizar o OpenFeign e o Circuit Breaker do Resilience4J em um projeto Spring Boot com Gradle, utilizando Java 21. Também veremos por que é vantajoso usar Gradle com Kotlin ao invés de Groovy.

O que é um circuit breaker?

Um circuit breaker é essencial em comunicações síncronas REST para garantir a resiliência e robustez do sistema. Ele monitora interações entre componentes e bloqueia temporariamente solicitações a serviços com falhas ou alta latência, prevenindo sobrecargas e falhas em cascata. Isso permite que o sistema continue operando, melhora a latência percebida pelo usuário e fornece visibilidade sobre a saúde dos serviços. Além disso, o circuit breaker testa periodicamente os serviços problemáticos, reativando-os quando voltam a funcionar corretamente, o que garante uma recuperação controlada e eficiente. Possui também um esquema de fallback, que permite tratar APIs problemáticas.

Configuração do Projeto

  1. Inicializando o Projeto Spring Boot: Para começar, vamos criar um novo projeto Spring Boot. Você pode usar o Spring Initializr (https://start.spring.io/) para gerar um esqueleto de projeto com as dependências básicas. Selecione as seguintes dependências:
    • Spring Web
    • Spring Cloud OpenFeign
    • Spring Cloud Starter Circuit Breaker Resilience4J
  2. Como estamos utilizando Gradle, certifique-se de escolher esta opção no Initializr.
  3. Configuração do Gradle com Kotlin DSL: No arquivo build.gradle.kts (Gradle Kotlin DSL), adicione as seguintes dependências:
dependencies {

    implementation("org.springframework.boot:spring-boot-starter-web")
    // https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign
    implementation("org.springframework.cloud:spring-cloud-starter-openfeign:4.1.1")
    // https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-circuitbreaker-resilience4j
    implementation("org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j:3.1.1")
}

Configurando OpenFeign

  1. Habilitando o OpenFeign no Spring Boot: No arquivo principal da aplicação (Application.java), habilite o Feign adicionando a anotação @EnableFeignClients.
  2. Criando um Cliente Feign: Crie uma interface Feign para definir o cliente HTTP. Por exemplo:
@FeignClient(name = "metMuseumClient", url = "https://collection.metmuseum.org/public/collection/v1")
public interface MetMuseumClient {

    @GetMapping("/objects/{object_id}")
    ObjectResponse getObject(@PathVariable("object_id")int objectId);
}

Configurando o Circuit Breaker com Resilience4J

  1. Habilitando o Circuit Breaker no Feign: Configure o Feign para utilizar o Circuit Breaker do Resilience4J. Adicione as configurações no arquivo application.yml.
  2. Configurando o Feign com Circuit Breaker: Adicione a configuração para habilitar o Resilience4J Circuit Breaker nas chamadas Feign. Crie um configurador Feign na sua aplicação:

Criando uma Classe Service

@Service
@RequiredArgsConstructor
public class ArtObjectService {

    private final MetMuseumClient metMuseumClient;

    public ObjectResponse getObject(int objectId) {
        return metMuseumClient.getObject(objectId);
    }
}

Criando um RestController para Acionar o Cliente Feign

Para expor um endpoint REST que utilize o serviço criado, crie um controlador REST. Este controlador chamará o serviço que, por sua vez, utilizará o cliente Feign para obter os dados dos objetos do met museum.

@RestController
@RequestMapping("/met")
@RequiredArgsConstructor
public class ObjectController {

    private final ArtObjectService artObjectService;

    @GetMapping("/object/{object_id}")
    public ResponseEntity getObject(@PathVariable("object_id") int objectId){
        return  ResponseEntity.ok(artObjectService.getObject(objectId));
    }
}

Criando as configurações do Cliente Feign

spring:
  cloud:
    circuitbreaker:
      resilience4j:
        enabled: true
    openfeign:
      circuitbreaker:
        enabled: true
        alphanumeric-ids:
          enabled: true
      client:
        config:
          default:
            loggerlevel: full
            connectTimeout: 1000
            readTimeout: 1000

resilience4j:
  circuitbreaker:
    configs:
      default:
        registerHealthIndicator: true
        slidingWindowSize: 50 #como é baseado em tempo, ficará 50 segundos em monitoramento
        permittedNumberOfCallsInHalfOpenState: 3
        slidingWindowType: TIME_BASED #janela a ser monitorada
        minimumNumberOfCalls: 5
        waitDurationInOpenState: 500s
        failureRateThreshold: 3
        eventConsumerBufferSize: 10

Por que usar Gradle com Kotlin DSL ao invés de Groovy DSL

  1. Sintaxe Melhorada e Tipagem Estática: A sintaxe do Kotlin DSL é mais concisa e oferece tipagem estática, o que ajuda a detectar erros em tempo de compilação. Isso torna o processo de desenvolvimento mais seguro e reduz a probabilidade de erros em tempo de execução.
  2. Melhor Integração com IDEs: As IDEs, especialmente o IntelliJ IDEA, oferecem suporte superior para Kotlin DSL em comparação com Groovy DSL. A autocompletação, navegação de código e refatoração são mais eficientes e confiáveis, proporcionando uma melhor experiência de desenvolvimento.
  3. Consistência no Ecossistema Kotlin: Para equipes que já estão usando Kotlin em seus projetos, utilizar o Kotlin DSL para Gradle traz consistência no ecossistema de desenvolvimento. Isso facilita a curva de aprendizado e promove a reutilização de conhecimentos e práticas.
  4. Recursos Modernos do Kotlin: O Kotlin DSL aproveita recursos modernos do Kotlin, como lambdas, extensões de função e outras características avançadas, que permitem escrever scripts de build mais poderosos e expressivos.
  5. Manutenção a Longo Prazo: Gradle está investindo continuamente no Kotlin DSL, o que indica um forte suporte e melhorias futuras. Adotar o Kotlin DSL pode ser uma escolha estratégica para a manutenção e evolução a longo prazo dos scripts de build.

Conclusão

Configurar OpenFeign e o Circuit Breaker do Resilience4J em um projeto Spring Boot com Gradle e Java 21 é uma abordagem moderna e eficiente para criar microserviços resilientes. Usar Gradle com Kotlin DSL oferece várias vantagens sobre o Groovy, incluindo melhor suporte de IDE, tipagem estática e uma sintaxe mais clara e concisa. Experimente esta configuração em seu próximo projeto e veja como ela funciona.

Viu algum erro, tem alguma sugestão? Comenta aí.

Quer ver o código na íntegra? https://github.com/nathalia-amarals/openfeignresilienceconfig

Bibliografia:

Deixe um comentário

Do blog

About the author

Sophia Bennett is an art historian and freelance writer with a passion for exploring the intersections between nature, symbolism, and artistic expression. With a background in Renaissance and modern art, Sophia enjoys uncovering the hidden meanings behind iconic works and sharing her insights with art lovers of all levels. When she’s not visiting museums or researching the latest trends in contemporary art, you can find her hiking in the countryside, always chasing the next rainbow.