API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) · leksjon

Feilhåndtering og fallback-mekanismer

Implementer egendefinert feilhåndtering og definer fallback-mekanismer for kontrollert funksjonsreduksjon når tjenester ikke er tilgjengelige.

Leksjon 3 av 411 trinn

Feilhåndtering og fallback-mekanismer er en gratis leksjon i API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i API-gateway og reverse proxy (Nginx + Spring Cloud Gateway), og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) inneholder totalt 4 leksjoner.

Introduksjon til robust feilhåndtering

I en mikrotjenestearkitektur kan tjenester feile. En API-gateway trenger robust feilhåndtering og fallback-mekanismer for å sikre at hele systemet forblir stabilt og brukervennlig.

I denne leksjonen ser vi på hvordan Spring Cloud Gateway kan hjelpe Dem med å håndtere feil på en kontrollert måte og tilby alternative svar når backend-tjenester ikke er tilgjengelige.

Standardfeil i gatewayen

Som standard gir Spring Cloud Gateway generiske feilsvar når en rutet tjeneste ikke kan nås eller returnerer en feil. Disse inneholder ofte standardiserte HTTP-statuskoder (som 500 Internal Server Error og 503 Service Unavailable) og enkel JSON.

Selv om disse svarene fungerer, er standardmeldingene vanligvis lite brukervennlige og kan avsløre interne detaljer. Tilpasning er viktig for å gi en god brukeropplevelse.

Tilpasse feilsvar

For å forbedre brukeropplevelsen kan vi tilpasse feilsvarene fra gatewayen. Dette gjør det mulig å:

vise tydelige og merkevaretilpassede feilmeldinger.
skjule sensitive interne feildetaljer.
returnere ensartede feilformater på tvers av alle API-er.

Spring Cloud Gateway er bygget på Spring WebFlux og lar oss implementere egendefinerte ErrorWebExceptionHandler-komponenter.

Eksempel på egendefinert feilhåndtering

La oss opprette en egendefinert feilhåndtering som fanger opp feil og returnerer et forenklet JSON-svar. Denne håndteringen erstatter standardsiden for feil.

Kjør denne koden og prøv å gå til /fail. Da vil De se den egendefinerte meldingen vår!

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.nio.charset.StandardCharsets;

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

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("nonexistent_service", r -> r.path("/fail/**")
                .uri("http://localhost:9999")) // Route to a non-existent service
            .build();
    }
}

@Configuration
@Order(-1) // Ensure this handler runs before default ones
class CustomJsonErrorWebExceptionHandler implements ErrorWebExceptionHandler {

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);

        String errorBody = "{\"status\":500, \"message\":\"Our service is temporarily unavailable. Please try again!\"}";
        DataBuffer buffer = response.bufferFactory().wrap(errorBody.getBytes(StandardCharsets.UTF_8));
        return response.writeWith(Mono.just(buffer));
    }
}

Forstå fallback-mekanismer

En fallback-mekanisme tilbyr en alternativ vei eller et alternativt svar når en primærtjeneste feiler eller blir utilgjengelig. I stedet for å vise en rå feilmelding kan gatewayen håndtere situasjonen på en kontrollert måte ved å:

returnere et standardsvar.
videresende til en statisk feilside.
kalle en dedikert fallback-tjeneste.

Fallback-mekanismer er avgjørende for robusthet og for å hindre kjedefeil.

Fallback-strategier for gatewayen

Spring Cloud Gateway støtter primært fallback-mekanismer gjennom integrasjonen med circuit breakers (som Resilience4j, omtalt i forrige leksjon). Når en circuit breaker slår ut, kan den kalle en fallback i stedet for å feile fullstendig.

En vanlig måte å definere denne fallbacken på er å bruke metoden setFallbackUri() i circuit breaker-filteret, ofte med en forward:-URI som mål.

Implementere en enkel fallback-rute

Den enkleste fallback-løsningen er å videresende forespørselen til en annen URI i selve gatewayen. Dette kan være en statisk HTML-side, en enkel Spring-kontrollermetode eller til og med en annen intern rute.

Prefikset forward: i fallbackUri forteller gatewayen at forespørselen skal håndteres internt, uten å foreta et nytt eksternt HTTP-kall.

Konfigurere en fallback-rute

Slik kan De konfigurere en rute med fallback. Hvis backend-tjenesten for ruten /api/** feiler (for eksempel fordi en circuit breaker har åpnet), videresender gatewayen forespørselen til vårt lokale endepunkt /fallback.

Prøv å gå til /api/hello når localhost:9000 er nede.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController // For our simple fallback endpoint
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("backend_service", r -> r.path("/api/**")
                .filters(f -> f.circuitBreaker(config -> config
                    .setName("myCircuitBreaker")
                    .setFallbackUri("forward:/fallback"))) // Fallback URI
                .uri("http://localhost:9000")) // A service that might fail
            .build();
    }

    // This method acts as the fallback service
    @GetMapping("/fallback")
    public String fallback() {
        return "Service is currently unavailable. Please try again later!";
    }
}

Fallback til en dedikert tjeneste

For mer komplekse scenarier kan De konfigurere fallbackUri til å peke på en dedikert mikrotjeneste. Denne «fallback-tjenesten» kan:

vise omfattende feilsider.
tilby bufrede data eller standarddata.
logge detaljert informasjon om feil.

Denne tilnærmingen sentraliserer logikken for feilhåndtering og holder gateway-konfigurasjonen ryddigere.

Test kunnskapen Deres

Hvilke av de følgende er fordeler ved å implementere egendefinert feilhåndtering og fallback-mekanismer i en API-gateway?

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte vi hvor viktig robust feilhåndtering og fallback-mekanismer er i Spring Cloud Gateway. Vi så på hvordan man kan:

tilpasse standardfeilsvar ved hjelp av ErrorWebExceptionHandler.
implementere enkle fallback-løsninger ved hjelp av setFallbackUri("forward:") sammen med circuit breakers.
forstå fordelene med dedikerte fallback-tjenester i mer avanserte scenarier.

Disse teknikkene er viktige for å bygge robuste og brukervennlige mikrotjenesteapplikasjoner.

Gratis å komme i gang

Lær deg API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feilhåndtering og fallback-mekanismer» gratis?

Ja – hele teksten i «Feilhåndtering og fallback-mekanismer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av API-gateway og reverse proxy (Nginx + Spring Cloud Gateway)-kurset, kan du oppgradere til CoddyKit PRO. Kurset i API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) inneholder totalt 4 leksjoner.

Hva lærer jeg i «Feilhåndtering og fallback-mekanismer»?

Implementer egendefinert feilhåndtering og definer fallback-mekanismer for kontrollert funksjonsreduksjon når tjenester ikke er tilgjengelige. Du øver på API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med API-gateway og reverse proxy (Nginx + Spring Cloud Gateway)?

Ingen tidligere erfaring er nødvendig. API-gateway og reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Feilhåndtering og fallback-mekanismer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne API-gateway og reverse proxy (Nginx + Spring Cloud Gateway)-leksjonen?

Ja. Alle API-gateway og reverse proxy (Nginx + Spring Cloud Gateway)-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Circuit breakers med Resilience4j
Konfigurering av nye forsøk og tidsavbrudd
Feilhåndtering og fallback-mekanismer
Skottisolasjon og hastighetsbegrensning for robusthet

← Tilbake til API-gateway og reverse proxy (Nginx + Spring Cloud Gateway)