API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) · Lektion

Circuit breakers med Resilience4j

Integrera Resilience4j för att implementera circuit breaker-mönster och förhindra kedjereaktioner av fel i mikrotjänster.

Lektion 1 av 412 steg

Circuit breakers med Resilience4j är en gratis lektion i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för API-gateway och reverse proxy (Nginx + Spring Cloud Gateway), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) innehåller totalt 4 lektioner.

Mikrotjänster och motståndskraft

I en mikrotjänstarkitektur samarbetar många små tjänster. Även om detta är kraftfullt kan kopplingarna mellan tjänsterna vara en svaghet.

Om en tjänst blir långsam eller slutar svara kan förfrågningar samlas på hög. Då måste andra tjänster vänta, vilket i sin tur gör även dem långsammare. Detta kallas en kaskadfelfunktion och kan få hela systemet att sluta fungera!

Vad är en Circuit Breaker?

Tänk på en automatsäkring i ert hem. Om det blir en överbelastning löser den ut för att förhindra skador.

I programvara fungerar mönstret Circuit Breaker på samma sätt. Det stoppar fortsatta anrop till en tjänst som inte fungerar, så att tjänsten får tid att återhämta sig och felet inte sprids.

I stället för att fortsätta anropa en trasig tjänst gör Circuit Breaker en snabb felhantering genom att omedelbart returnera ett fel eller ett reservsvar.

Introduktion till Resilience4j

Resilience4j är ett lättviktigt bibliotek för feltålighet, inspirerat av Netflix Hystrix. Det är utformat för funktionell programmering och integreras sömlöst med Spring Boot.

Det tillhandahåller flera mönster för feltålighet, bland annat Circuit Breaker, Rate Limiter, Retry och Bulkhead, som hjälper er att bygga mer robusta mikrotjänster.

En Circuit Breakers tre tillstånd

En Circuit Breaker arbetar i tre huvudtillstånd:

CLOSED: Detta är normaltillståndet. Förfrågningar går vidare till den skyddade tjänsten. Om antalet fel överskrider ett konfigurerat tröskelvärde övergår den till OPEN.
OPEN: Inga förfrågningar tillåts passera. Alla anrop misslyckas omedelbart. Efter en konfigurerad väntetid övergår den till HALF_OPEN.
HALF_OPEN: Ett begränsat antal testförfrågningar tillåts. Om de lyckas stängs kretsen igen. Om de misslyckas öppnas den på nytt.

Konfigurera Resilience4j

För att använda Resilience4j med Spring Boot måste ni lägga till nödvändiga beroenden i er pom.xml (för Maven) eller build.gradle (för Gradle).

Dessa beroenden tillhandahåller den centrala Circuit Breaker-funktionaliteten och Spring Boot-integrationen.

<!-- Maven (pom.xml) -->
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.1</version>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-circuitbreaker</artifactId>
    <version>1.7.1</version>
</dependency>

Grundläggande Circuit Breaker-konfiguration

Ni konfigurerar Circuit Breakers i application.yml eller application.properties. Här är ett grundläggande exempel:

failureRateThreshold: Den procentuella andel fel som krävs för att öppna kretsen.
waitDurationInOpenState: Hur länge kretsen förblir öppen.
slidingWindowSize: Antalet anrop som ska beaktas när felfrekvensen beräknas.

resilience4j.circuitbreaker:
  instances:
    myBackendService:
      failureRateThreshold: 50
      waitDurationInOpenState: 5s
      slidingWindowType: COUNT_BASED
      slidingWindowSize: 10

Skydda ett tjänsteanrop

Med Spring Boot kan ni enkelt tillämpa en Circuit Breaker genom att använda annoteringen @CircuitBreaker på metoden som ni vill skydda.

Ange namnet på den konfigurerade Circuit Breaker-instansen och eventuellt en fallbackMethod.

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;

@Service
public class MyExternalService {

    @CircuitBreaker(name = "myBackendService", fallbackMethod = "reliableFallback")
    public String callReliableApi() {
        // Simulate an API call that might fail
        if (Math.random() < 0.7) {
            throw new RuntimeException("API call failed!");
        }
        return "Data from API";
    }

    public String reliableFallback(Throwable t) {
        return "Fallback: Service is currently unavailable.";
    }
}

Praktiskt arbete med Resilience4j

Låt oss se en Circuit Breaker i praktiken! Det här körbara exemplet simulerar anrop till en tjänst som ofta misslyckas och visar hur tillstånden växlar.

Observera hur kretsen öppnas efter flera fel och sedan försöker övergå till halvöppet tillstånd efter en fördröjning.

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.vavr.CheckedFunction0;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50) // 50% failure rate to open
            .waitDurationInOpenState(Duration.ofSeconds(2))
            .slidingWindowSize(10)
            .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
            .build();

        CircuitBreaker circuitBreaker = CircuitBreaker.of("myTestService", config);

        circuitBreaker.getEventPublisher()
            .onStateTransition(event -> System.out.println("\nCircuit Breaker State Transition: " + event.getOldState() + " -> " + event.getNewState() + "\n"));

        System.out.println("Simulating 20 service calls...");
        for (int i = 1; i <= 20; i++) {
            try {
                String result = circuitBreaker.executeCheckedSupplier(
                    (CheckedFunction0<String>) () -> {
                        if (Math.random() < 0.6) { // Simulate 60% failure
                            System.out.println("  Call " + i + ": Service failed!");
                            throw new RuntimeException("Simulated Service Error");
                        }
                        System.out.println("  Call " + i + ": Service succeeded.");
                        return "Data from Service";
                    });
                System.out.println("  -> Result: " + result);
            } catch (Throwable t) {
                System.out.println("  -> Result: Fallback/Circuit OPEN! Message: " + t.getMessage());
            }
            try {
                Thread.sleep(200); // Pause to observe behavior
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("\nSimulation complete. Final state: " + circuitBreaker.getState());
    }
}

Hantera reservlösningar på ett smidigt sätt

fallbackMethod är avgörande. När den skyddade metoden misslyckas (antingen på grund av ett undantag eller för att kretsen är OPEN) anropas den här metoden i stället.

Den gör det möjligt för er att tillhandahålla ett standardsvar, cachad data eller en förenklad användarupplevelse, så att användarens förfrågan inte misslyckas helt.

Se alltid till att reservmetoden har samma returtyp och tar emot en Throwable som sitt sista argument.

Viktiga konfigurationsparametrar

Genom att förstå dessa parametrar kan ni finjustera er Circuit Breaker:

failureRateThreshold: Den procentuella andel fel som gör att kretsen öppnas.
waitDurationInOpenState: Hur länge kretsen förblir i tillståndet OPEN innan den övergår till HALF_OPEN.
slidingWindowSize: Antalet anrop som registreras och används för att beräkna felfrekvensen.
slidingWindowType: Kan vara COUNT_BASED (ett fast antal anrop) eller TIME_BASED (anrop inom ett visst tidsfönster).

Snabb kontroll: Circuit Breaker-tillstånd

Vilket av följande villkor kan få en Circuit Breaker att övergå från tillståndet CLOSED till OPEN i Resilience4j?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Skydda era tjänster

Ni har lärt er att Circuit Breakers är ett viktigt mönster för att bygga motståndskraftiga mikrotjänster. De förhindrar kaskadfel genom att lösa ut när en tjänst inte fungerar som den ska och därmed ge den tid att återhämta sig.

Resilience4j erbjuder ett lättviktigt och kraftfullt sätt att implementera dessa mönster i era Spring Cloud Gateway- eller Spring Boot-applikationer. Nu förstår ni dess tillstånd, grundläggande konfiguration och hur det kan användas för att skydda era tjänster.

Gratis att börja

Lär dig API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Circuit breakers med Resilience4j” gratis?

Ja – hela texten till ”Circuit breakers med Resilience4j” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway), kan Ni uppgradera till CoddyKit PRO. Kursen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) innehåller totalt 4 lektioner.

Vad lär jag mig i ”Circuit breakers med Resilience4j”?

Integrera Resilience4j för att implementera circuit breaker-mönster och förhindra kedjereaktioner av fel i mikrotjänster. Ni övar på API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)?

Du behöver inga förkunskaper. Utbildningen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Circuit breakers med Resilience4j”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)-lektionen?

Ja. Varje API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Circuit breakers med Resilience4j
Konfiguration av omförsök och tidsgränser
Felhantering och fallback-mekanismer
Bulkheads och hastighetsbegränsning för motståndskraft

← Tillbaka till API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)