Graceful degradation in Microservices - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to implement a fallback response in a microservice.

Microservices

response = call_service() or [1]

Drag options to blanks, or click blank then click option'

Araise Exception()

B"default response"

CNone

Dexit()

Attempts:

3 left

💡 Hint

Common Mistakes

Raising an exception stops the flow instead of degrading gracefully.

Using a default response ensures the system continues working even if the service call fails.

2fill in blank

medium

Complete the code to check service health before calling it.

Microservices

if [1]():
    response = call_service()
else:
    response = "fallback"

Drag options to blanks, or click blank then click option'

Aservice.is_busy

Bservice.is_down

Cservice.is_error

Dservice.is_available

Attempts:

3 left

💡 Hint

Common Mistakes

Using a negative health check leads to wrong logic.

Checking if the service is available helps decide whether to call it or use fallback.

3fill in blank

hard

Fix the error in the circuit breaker pattern code.

Microservices

if circuit_breaker.[1]():
    response = call_service()
else:
    response = "fallback"

Drag options to blanks, or click blank then click option'

Ais_disabled

Bis_open

Cis_closed

Dis_half_open

Attempts:

3 left

💡 Hint

Common Mistakes

Using is_open allows calls when it should block them.

The circuit breaker must be closed to allow calls; if open, calls are blocked.

4fill in blank

hard

Fill both blanks to implement a timeout fallback in a microservice call.

Microservices

try:
    response = call_service(timeout=[1])
except [2]:
    response = "fallback"

Drag options to blanks, or click blank then click option'

A5

BTimeoutError

CConnectionError

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong exception type causes fallback not to trigger.

Setting a timeout of 5 seconds and catching TimeoutError allows graceful fallback on delays.

5fill in blank

hard

Fill all three blanks to create a fallback cache mechanism.

Microservices

cache = [1]()
if not cache.has(key):
    data = call_service()
    cache.[2](key, data)
else:
    data = cache.[3](key)

Drag options to blanks, or click blank then click option'

ACacheStore

Bset

Cget

Ddelete

Attempts:

3 left

💡 Hint

Common Mistakes

Using delete instead of get loses cached data.

CacheStore is the cache class; set stores data; get retrieves data for fallback.

Practice

1. What is the main goal of graceful degradation in microservices?

easy

A. To increase the number of microservices for better scaling

B. To immediately stop all services when one fails

C. To keep the system running with reduced functionality during failures

D. To replace microservices with a monolithic architecture

Solution

1. Step 1: Understand the concept of graceful degradation

   Graceful degradation means the system continues to work even if some parts fail, but with limited features.

2. Step 2: Identify the goal in microservices context

   In microservices, it ensures users still get responses, possibly simpler or fallback, instead of total failure.

3. Final Answer:

   To keep the system running with reduced functionality during failures -> Option C

4. Quick Check:

   Graceful degradation = reduced functionality during failure [OK]

Hint: Graceful degradation means partial working, not full stop [OK]

Common Mistakes:

• Thinking graceful degradation means full system shutdown
• Confusing graceful degradation with scaling techniques
• Assuming it replaces microservices with monolith

2. Which of the following is a correct way to implement graceful degradation in a microservice call?

easy

A. Restart the entire microservice cluster immediately

B. Return an error and stop the entire request flow

C. Ignore the failure and return no response

D. Use a fallback response when the called service is unavailable

Solution

1. Step 1: Identify how graceful degradation handles failures

   It uses fallback responses or simpler data to keep the system responsive.

2. Step 2: Match the option that uses fallback

   Use a fallback response when the called service is unavailable describes using fallback response when a service is down, which is correct.

3. Final Answer:

   Use a fallback response when the called service is unavailable -> Option D

4. Quick Check:

   Fallback response = graceful degradation [OK]

Hint: Fallback response is key to graceful degradation [OK]

Common Mistakes:

• Stopping entire request instead of fallback
• Ignoring failure without response
• Restarting cluster is not graceful degradation

3. Consider this pseudocode for a microservice call with graceful degradation:

response = callService()
if response == null:
    response = getCachedData()
return response

What will be returned if callService() fails?

medium

A. Cached data as fallback

B. Null value

C. An error message

D. Empty string

Solution

1. Step 1: Analyze the code flow when callService() fails

   If callService() returns null (failure), the code fetches cached data as fallback.

2. Step 2: Determine the returned value

   The fallback cached data is returned instead of null or error.

3. Final Answer:

   Cached data as fallback -> Option A

4. Quick Check:

   Fallback cached data returned on failure [OK]

Hint: Null response triggers fallback to cached data [OK]

Common Mistakes:

• Assuming error message is returned
• Thinking null is returned directly
• Confusing empty string with fallback data

4. A microservice uses this code snippet for graceful degradation:

try {
  data = fetchFromService()
} catch (Exception e) {
  data = null
}
return data.toString()

What is the main problem with this code?

medium

A. It does not handle exceptions properly

B. It returns null.toString() causing a runtime error

C. It always returns an empty string

D. It retries the service call infinitely

Solution

1. Step 1: Understand exception handling and return statement

   If fetchFromService() fails, data is set to null, then data.toString() is called.

2. Step 2: Identify the error caused by calling toString() on null

   Calling toString() on null causes a runtime NullPointerException or similar error.

3. Final Answer:

   It returns null.toString() causing a runtime error -> Option B

4. Quick Check:

   Calling toString() on null causes error [OK]

Hint: Calling method on null causes runtime error [OK]

Common Mistakes:

• Ignoring null check before toString()
• Assuming exception is handled fully
• Thinking it retries infinitely

5. You design a microservice system where the payment service may fail. To apply graceful degradation, which approach is best?

hard

A. Return a simplified confirmation without payment details and log failure for retry

B. Block the entire order process until payment service recovers

C. Send an error response to the user immediately without fallback

D. Remove the payment service and process orders without payment

Solution

1. Step 1: Understand graceful degradation for critical service failure

   When payment service fails, system should still respond with limited info, not block or error out.

2. Step 2: Evaluate options for best graceful degradation

   Return a simplified confirmation without payment details and log failure for retry returns simplified confirmation and logs failure for retry, maintaining user experience and system reliability.

3. Final Answer:

   Return a simplified confirmation without payment details and log failure for retry -> Option A

4. Quick Check:

   Simplified response + retry = graceful degradation [OK]

Hint: Simplify response and log failure for retry [OK]

Common Mistakes:

• Blocking entire process on failure
• Sending immediate error without fallback
• Removing critical service entirely