Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer
Wykorzystają Państwo Spring Cloud LoadBalancer do równoważenia obciążenia po stronie klienta podczas kierowania żądań do wielu instancji usługi.
Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer to bezpłatna lekcja API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
What is Client-Side Load Balancing?
In a microservices architecture, you often have multiple instances of the same service running. Client-side load balancing means the client (the service consumer) is responsible for choosing which instance to send a request to.
Unlike server-side load balancing (like Nginx), where a central proxy distributes requests, here the client actively participates in the decision. This can reduce network hops and improve responsiveness.
Introducing Spring Cloud LoadBalancer
Spring Cloud LoadBalancer is a client-side load balancer that works seamlessly with Spring Cloud applications. It's the modern successor to Netflix Ribbon in the Spring ecosystem.
It integrates with service discovery mechanisms (like Eureka or Consul) to get a list of available service instances and then applies a load balancing algorithm to select one for each request.
Adding LoadBalancer to Your Project
To use Spring Cloud LoadBalancer, you typically add the spring-cloud-starter-loadbalancer dependency to your Spring Boot project. This starter brings in all necessary components.
It's often used alongside a service discovery client (e.g., Eureka Client) so LoadBalancer knows which service instances are available.
Load Balancing with RestTemplate
You can easily enable client-side load balancing for RestTemplate by adding the @LoadBalanced annotation to its bean definition. This tells Spring Cloud to intercept calls and use LoadBalancer.
Notice how we call the service using its logical name (MY-SERVICE) instead of a specific IP: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);
}
}Load Balancing with WebClient
For reactive applications, WebClient is the preferred choice. You can enable load balancing for it by applying @LoadBalanced to a WebClient.Builder bean.
Similar to RestTemplate, you use the service's logical name in the URL, and LoadBalancer handles the instance resolution.
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));
}
}How Service Discovery Powers It
Spring Cloud LoadBalancer doesn't magically know about service instances. It relies on service discovery, like Eureka or Consul, to provide a list of healthy, available instances for a given service ID.
When a client makes a request using a logical service name (e.g., MY-SERVICE), LoadBalancer queries the service registry, gets the list of instances, and then picks one.
Default Strategy: Round Robin
By default, Spring Cloud LoadBalancer uses the Round Robin algorithm. This means it cycles through the available service instances in order, distributing requests evenly.
For example, if you have three instances (A, B, C), the first request goes to A, the second to B, the third to C, the fourth back to A, and so on.
Gateway Routing with LoadBalancer
Spring Cloud Gateway automatically integrates with Spring Cloud LoadBalancer. When you define a route using a service ID (e.g., lb://MY-SERVICE), the Gateway uses LoadBalancer to resolve the actual instance address.
This means your gateway can route requests to multiple instances of a backend service without you needing to manually manage their IPs and ports.
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();
}
}Customizing Load Balancing Strategies
While Round Robin is the default, Spring Cloud LoadBalancer is extensible. You can configure custom load balancing algorithms if your needs are more complex.
For example, you might want a 'Least Connections' strategy, which sends requests to the instance with the fewest active connections, or a 'Sticky Session' approach to route a user's requests consistently to the same server.
Quick Check: LoadBalancer Purpose
Which of the following are primary benefits or characteristics of using Spring Cloud LoadBalancer?
Recap: Client-Side Load Balancing
We've explored Spring Cloud LoadBalancer, a key component for building resilient microservices. It enables clients to intelligently distribute requests across multiple instances of a service.
- It's a client-side solution, distinct from server-side proxies.
- It works with service discovery (e.g., Eureka) to find service instances.
- You can use it with
@LoadBalanced RestTemplateorWebClient.Builder. - It's automatically integrated into Spring Cloud Gateway for routing.
- The default load balancing strategy is Round Robin.
This ensures your applications can scale horizontally and remain available even if some service instances fail.
Ucz się API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 12
- Lekcje
- 48
Często zadawane pytania
Czy lekcja „Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer” jest bezpłatna?
Tak — pełny tekst „Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway), przejdź na CoddyKit PRO. Kurs API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) zawiera 4 lekcji w sumie.
Co nauczysz się w „Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer”?
Wykorzystają Państwo Spring Cloud LoadBalancer do równoważenia obciążenia po stronie klienta podczas kierowania żądań do wielu instancji usługi. Ćwiczysz API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)?
Nie wymagamy żadnego doświadczenia. API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)?
Tak. Każda lekcja API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Integracja z Eureka i Consul
- Dynamiczne trasowanie z wykrywaniem usług
- Równoważenie obciążenia za pomocą Spring Cloud LoadBalancer
- URI lb:// i lokalizator discovery