liveBook · Manning

Resilience

As explained in Platform Engineering on Kubernetes

Resilience is the ability of an application or service to continue providing useful functionality despite failures in its components or dependencies.

Resilience keeps an application useful when services or dependencies fail. Instead of propagating an Agenda service failure, the Frontend can serve cached data while other application areas remain available. section 2.4.2

Build resilience into service boundaries with practical failure-handling mechanisms:

  • Use cached responses so user-facing components can continue operating with limited functionality. section 2.4.2
  • Run at least two replicas for services where minimizing downtime matters, especially user-facing components. section 2.6
  • Add automatic retries for service-to-service requests, using exponential backoff to avoid overloading failing services and networks. section 7.1.2
  • Treat downstream contracts, networks, and services as failure points rather than assuming they always behave as expected. section 7.1.2

Keeping the Conference application available

Scale the Agenda deployment to zero replicas. The container stops answering requests, but the Frontend displays cached agenda entries, while users can still access other services such as the Call for Proposals form. The Back Office identifies the Agenda service as unhealthy. section 2.4.2

kubectl scale --replicas=0 deployments/conference-agenda-service-deployment

Use the Kubernetes scaling command to deliberately remove Agenda replicas and observe the application's fallback behavior. section 2.4.2

How Platform Engineering on Kubernetes covers it

How deep it goes
Demonstrates caches, replicas, retries, and exponential backoff, but does not standardize behavior across technology stacks.
Examples
Uses a scaled-down Agenda service, cached agenda entries, unhealthy-service reporting, replicas, and Java or Go retry libraries.
What it assumes
Assumes distributed services and Kubernetes operations, while demonstrating failure scenarios through a walking-skeleton application.
What you can do after
Apply it via Kubernetes scaling, cached fallbacks, service replicas, and language-specific retry libraries.
How it connects
Connects distributed systems with Kubernetes, caching, service-to-service interaction, retries, replicas, and exponential backoff.

Also explained in

Compare how 13 books explain resilience →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Platform Engineering on Kubernetes. The section links point to the parts of the book it draws on.