Mise en œuvre de solutions de secours et de délais d’expiration
Découvrez comment mettre en œuvre des mécanismes de secours et des délais d’expiration afin de gérer élégamment l’indisponibilité d’un service ou les réponses lentes.
Mise en œuvre de solutions de secours et de délais d’expiration est une leçon Microservices Communication Patterns (Saga, Circuit Breaker) gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Microservices Communication Patterns (Saga, Circuit Breaker), et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Microservices Communication Patterns (Saga, Circuit Breaker) comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Welcome to Resilience Patterns
In this lesson, we'll dive into two crucial patterns for building resilient microservices: Fallbacks and Timeouts.
These patterns help your applications gracefully handle failures and slow responses from other services, making your system more robust and reliable.
What is a Fallback?
A fallback mechanism provides an alternative course of action when a primary operation fails or encounters an error.
- It ensures your application can still respond, even if partially, instead of completely failing.
- Think of it as a plan B for your service calls.
- This leads to graceful degradation, where the system provides reduced functionality rather than total failure.
Fallback in Action: Default Data
Imagine an e-commerce site. If the service providing personalized product recommendations fails, you wouldn't want the entire page to break.
A fallback could display:
- Popular items (default list)
- Cached recommendations
- A simple message like 'Recommendations currently unavailable'
The user experience remains intact, even with a minor issue.
Coding a Simple Fallback
Let's see a basic Java example. Here, if our 'external service' throws an error, we catch it and return a default value instead of letting the application crash.
public class FallbackExample {
public String getProductRecommendation() {
try {
// Simulate calling an external service that might fail
if (Math.random() < 0.5) {
throw new RuntimeException("Service unavailable!");
}
return "Personalized Recommendation A";
} catch (Exception e) {
// Fallback: return a default recommendation
System.out.println("Fallback activated: " + e.getMessage());
return "Default Popular Product";
}
}
public static void main(String[] args) {
FallbackExample app = new FallbackExample();
System.out.println("Recommendation: " + app.getProductRecommendation());
System.out.println("Recommendation: " + app.getProductRecommendation());
}
}Why Do We Need Timeouts?
While fallbacks handle failures, timeouts address slow responses. A service might not fail outright, but it could take too long to respond.
- Resource Exhaustion: Waiting indefinitely ties up resources (threads, connections).
- Cascading Failures: A slow service can make other dependent services slow, leading to a system-wide slowdown.
Timeouts set a maximum duration for an operation.
Types of Timeouts
When making network calls, you'll often encounter different types of timeouts:
- Connection Timeout: The maximum time allowed to establish a connection to the remote service. If no connection is made within this time, it fails.
- Read Timeout: The maximum time allowed for data to be received after the connection is established. If the service stops sending data, this timeout triggers.
- Request Timeout: An overall timeout for the entire operation, from start to finish. This often encompasses both connection and read timeouts.
Setting a Request Timeout
In Java, setting timeouts depends on the client library you're using (e.g., OkHttp, HttpClient). Conceptually, it looks like this:
HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(5))
.build();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("http://slowservice.com/data"))
.timeout(Duration.ofSeconds(10)) // Request timeout
.GET()
.build();This ensures your request won't hang forever.
Combining Timeout & Fallback
Timeouts and fallbacks are powerful when used together. A timeout triggers a failure, which can then be handled by a fallback.
Let's extend our previous example. We'll simulate a slow service call. If it takes too long, a timeout will occur, and our fallback will provide a default response.
import java.util.concurrent.*;
public class TimeoutFallbackExample {
public String getProductRecommendationWithTimeout() {
ExecutorService executor = Executors.newSingleThreadExecutor();
try {
Future<String> future = executor.submit(() -> {
// Simulate a slow external service
long delay = (long) (Math.random() * 3000) + 1000; // 1-4 seconds
Thread.sleep(delay);
return "Personalized Recommendation B";
});
// Wait for the result, but only for 2 seconds
return future.get(2, TimeUnit.SECONDS);
} catch (TimeoutException e) {
System.out.println("Timeout occurred: " + e.getMessage());
return "Fallback: Timed out default product";
} catch (Exception e) {
System.out.println("Other error: " + e.getMessage());
return "Fallback: Error default product";
} finally {
executor.shutdown();
}
}
public static void main(String[] args) {
TimeoutFallbackExample app = new TimeoutFallbackExample();
System.out.println("Recommendation: " + app.getProductRecommendationWithTimeout());
System.out.println("Recommendation: " + app.getProductRecommendationWithTimeout());
}
}Benefits of Using Both
By combining timeouts and fallbacks, you achieve a higher level of resilience:
- Improved User Experience: Users don't wait indefinitely for a page to load or an operation to complete.
- Resource Protection: Your services don't exhaust resources waiting for unresponsive dependencies.
- System Stability: Prevents cascading failures, where one slow service brings down many others.
- Predictable Behavior: Your system behaves predictably even under stress.
Quick Check: Resilience
You are designing a microservice that calls an external payment gateway. If the gateway is slow or unavailable, you want to:
- Prevent your service from hanging indefinitely.
- Show a 'Payment currently unavailable' message to the user instead of an error page.
Which resilience patterns should you prioritize for this scenario?
Recap: Fallbacks & Timeouts
Great job! You've learned about two essential resilience patterns:
- Fallbacks: Provide alternative responses to gracefully handle failures, ensuring a better user experience.
- Timeouts: Set limits on how long an operation can take, preventing resource exhaustion and cascading failures from slow services.
Using these patterns together makes your microservices more robust and reliable.
Questions Fréquemment Posées
La leçon « Mise en œuvre de solutions de secours et de délais d’expiration » est-elle gratuite ?
Oui — le texte complet de « Mise en œuvre de solutions de secours et de délais d’expiration » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Microservices Communication Patterns (Saga, Circuit Breaker), passe à CoddyKit PRO. Le cours Microservices Communication Patterns (Saga, Circuit Breaker) comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Mise en œuvre de solutions de secours et de délais d’expiration » ?
Découvrez comment mettre en œuvre des mécanismes de secours et des délais d’expiration afin de gérer élégamment l’indisponibilité d’un service ou les réponses lentes. Tu pratiques Microservices Communication Patterns (Saga, Circuit Breaker) avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Microservices Communication Patterns (Saga, Circuit Breaker) ?
Aucune expérience préalable n'est requise. Microservices Communication Patterns (Saga, Circuit Breaker) sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Mise en œuvre de solutions de secours et de délais d’expiration » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Microservices Communication Patterns (Saga, Circuit Breaker) ?
Oui. Chaque leçon Microservices Communication Patterns (Saga, Circuit Breaker) inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Pourquoi la résilience est importante
- Fondamentaux du modèle de nouvelle tentative
- Mise en œuvre de solutions de secours et de délais d’expiration
- Le modèle Bulkhead