Lastbalansering med Spring Cloud LoadBalancer
Använd Spring Cloud LoadBalancer för klientbaserad lastbalansering när förfrågningar dirigeras till flera instanser av en tjänst.
Lastbalansering med Spring Cloud LoadBalancer är en gratis lektion i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit. Detta är lektion 3 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.
Vad är lastbalansering på klientsidan?
I en mikrotjänstarkitektur körs ofta flera instanser av samma tjänst. Lastbalansering på klientsidan innebär att klienten (den som använder tjänsten) ansvarar för att välja vilken instans en begäran ska skickas till.
Till skillnad från lastbalansering på serversidan (som med Nginx), där en central proxy distribuerar begäranden, deltar klienten här aktivt i beslutet. Det kan minska antalet nätverkshopp och förbättra svarstiden.
Introduktion till Spring Cloud LoadBalancer
Spring Cloud LoadBalancer är en lastbalanserare på klientsidan som fungerar sömlöst med Spring Cloud-applikationer. Den är den moderna efterföljaren till Netflix Ribbon i Spring-ekosystemet.
Den integreras med mekanismer för service discovery (som Eureka eller Consul) för att hämta en lista över tillgängliga tjänsteinstanser och använder sedan en lastbalanseringsalgoritm för att välja en instans för varje begäran.
Lägg till LoadBalancer i ditt projekt
För att använda Spring Cloud LoadBalancer lägger ni vanligtvis till beroendet spring-cloud-starter-loadbalancer i ert Spring Boot-projekt. Denna starter innehåller alla nödvändiga komponenter.
Det används ofta tillsammans med en klient för service discovery (till exempel Eureka Client), så att LoadBalancer känner till vilka tjänsteinstanser som är tillgängliga.
Lastbalansering med RestTemplate
Ni kan enkelt aktivera lastbalansering på klientsidan för RestTemplate genom att lägga till annoteringen @LoadBalanced i dess bönedefinition. Då instrueras Spring Cloud att fånga upp anrop och använda LoadBalancer.
Observera att tjänsten anropas med dess logiska namn (MY-SERVICE) i stället för en specifik IP-adress och port.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
@SpringBootApplication
public class RestTemplateClient {
@LoadBalanced
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
public static void main(String[] args) {
SpringApplication.run(RestTemplateClient.class, args);
// Example usage (in a real app, this would be in a service)
// RestTemplate restTemplate = applicationContext.getBean(RestTemplate.class);
// String response = restTemplate.getForObject("http://MY-SERVICE/hello", String.class);
// System.out.println("Response from MY-SERVICE: " + response);
}
}Lastbalansering med WebClient
För reaktiva applikationer är WebClient det rekommenderade alternativet. Ni kan aktivera lastbalansering för den genom att använda @LoadBalanced på en böna av typen WebClient.Builder.
Precis som med RestTemplate använder ni tjänstens logiska namn i URL:en, och LoadBalancer hanterar instansupplösningen.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.function.client.WebClient;
@SpringBootApplication
public class WebClientClient {
@LoadBalanced
@Bean
public WebClient.Builder webClientBuilder() {
return WebClient.builder();
}
public static void main(String[] args) {
SpringApplication.run(WebClientClient.class, args);
// Example usage (in a real app, this would be in a service)
// WebClient webClient = applicationContext.getBean(WebClient.Builder.class).build();
// webClient.get().uri("http://MY-SERVICE/greet")
// .retrieve().bodyToMono(String.class)
// .subscribe(response -> System.out.println("Response: " + response));
}
}Så möjliggör service discovery detta
Spring Cloud LoadBalancer känner inte till tjänsteinstanser av sig självt. Det förlitar sig på service discovery, till exempel Eureka eller Consul, för att tillhandahålla en lista över friska och tillgängliga instanser för ett visst tjänste-ID.
När en klient gör en begäran med ett logiskt tjänstenamn (till exempel MY-SERVICE) frågar LoadBalancer tjänsteregistret, hämtar listan över instanser och väljer sedan en av dem.
Standardstrategi: Round Robin
Som standard använder Spring Cloud LoadBalancer algoritmen Round Robin. Det innebär att den går igenom de tillgängliga tjänsteinstanserna i tur och ordning och fördelar begärandena jämnt.
Om ni till exempel har tre instanser (A, B och C) går den första begäran till A, den andra till B, den tredje till C, den fjärde tillbaka till A och så vidare.
Gateway-routing med LoadBalancer
Spring Cloud Gateway integreras automatiskt med Spring Cloud LoadBalancer. När ni definierar en route med ett tjänste-ID (till exempel lb://MY-SERVICE) använder Gateway LoadBalancer för att slå upp den faktiska instansadressen.
Det innebär att er gateway kan routa begäranden till flera instanser av en backend-tjänst utan att ni behöver hantera deras IP-adresser och portar manuellt.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
@EnableDiscoveryClient // Enables service discovery client (e.g., Eureka)
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
.route("my_service_route", r -> r.path("/api/**")
.uri("lb://MY-SERVICE")) // 'lb://' indicates load-balanced service
.build();
}
}Anpassa lastbalanseringsstrategier
Även om Round Robin är standard är Spring Cloud LoadBalancer utbyggbart. Ni kan konfigurera anpassade lastbalanseringsalgoritmer om era behov är mer komplexa.
Ni kanske till exempel vill använda strategin ”Least Connections”, som skickar begäranden till den instans som har minst antal aktiva anslutningar, eller metoden ”Sticky Session” för att konsekvent routa en användares begäranden till samma server.
Snabb kontroll: LoadBalancers syfte
Vilka av följande är huvudsakliga fördelar med eller egenskaper hos Spring Cloud LoadBalancer?
Sammanfattning: lastbalansering på klientsidan
Ni har nu utforskat Spring Cloud LoadBalancer, en viktig komponent för att bygga motståndskraftiga mikrotjänster. Den gör det möjligt för klienter att intelligent fördela begäranden mellan flera instanser av en tjänst.
- Det är en lösning på klientsidan, skild från proxyservrar på serversidan.
- Den fungerar med service discovery (till exempel Eureka) för att hitta tjänsteinstanser.
- Den kan användas med
@LoadBalanced RestTemplateellerWebClient.Builder. - Den integreras automatiskt i Spring Cloud Gateway för routing.
- Standardstrategin för lastbalansering är Round Robin.
Detta säkerställer att era applikationer kan skalas horisontellt och förbli tillgängliga även om vissa tjänsteinstanser slutar fungera.
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
Vanliga frågor
Är lektionen ”Lastbalansering med Spring Cloud LoadBalancer” gratis?
Ja – hela texten till ”Lastbalansering med Spring Cloud LoadBalancer” 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 ”Lastbalansering med Spring Cloud LoadBalancer”?
Använd Spring Cloud LoadBalancer för klientbaserad lastbalansering när förfrågningar dirigeras till flera instanser av en tjänst. 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 3 av 4.
Hur lång tid tar lektionen ”Lastbalansering med Spring Cloud LoadBalancer”?
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
- Integrering med Eureka/Consul
- Dynamisk routning med tjänsteupptäckt
- Lastbalansering med Spring Cloud LoadBalancer
- URI:n lb:// och Discovery Locator