TechKnowSurge
TechKnowSurge Catalog Videos Service Redundancy
VideoSecurityFree

Service Redundancy

Service redundancy ensures that when a server fails, clients can seamlessly connect to another without losing session data or experiencing disruption. Load balancing and clustering are two primary approaches used to achieve this continuity.

⚑ Complete this video to capture a CTF flag worth 1 point.

About this video

True service redundancy requires more than redundant hardware—it demands that the services themselves remain available and that client connections transition smoothly when a failure occurs. A client connecting to a server establishes a session at the TCP or application layer, tied to a specific IP address. If that server goes offline, the client has no automatic way of knowing it should reconnect elsewhere, and any in-progress session data risks being lost entirely unless the environment is engineered to handle it. Solving these challenges requires deliberate architectural decisions around how traffic is routed and how session state is preserved across servers. Load balancing and clustering are two foundational strategies for achieving service-level redundancy, each operating differently but addressing overlapping concerns. A load balancer sits in front of the server pool and distributes incoming client connections across available servers, and when a server fails, the balancer simply redirects traffic to a healthy one. Session persistence can be maintained by storing session data on a shared backend, such as a database, so it remains accessible regardless of which server handles the next request. Clustering groups multiple servers into a unified pool that behaves as a single service, improving both availability and resilience. Depending on the specific uptime, scalability, and failover requirements of an environment, organizations may deploy load balancing, clustering, or a combination of both.

What you'll learn

What's covered

Service Redundancy

Key terms

Load Balancer
A device or software that distributes incoming network traffic across multiple servers to ensure availability and performance.
Redundancy
The duplication of critical components or systems to increase reliability and availability.
Failover
The automatic switching to a redundant system or component when the primary one fails.
Clustering
A configuration where multiple servers or nodes work together as a single logical system to provide high availability, load balancing, or both, so that service continues if one node fails.
Session Persistence
The ability to maintain a user's session data consistently across multiple servers in a load-balanced or clustered environment.

Topics

Service Redundancy Load Balancing Clustering Session Persistence High Availability Networking

Transcript

Service Redundancy

Often when I think about server redundancy, I'm thinking about the hardware: actual physical servers that have redundancy to them, or perhaps it's virtual servers and multiple virtual servers. But the software needs to be able to fail over as well. We need some sort of service redundancy. Whatever the case may be, what the client is actually connecting into is a service on those servers. So we need to think about the services that are running and how we create redundancy with them.

Here we have a laptop. That laptop is the client machine, and it's going to make a request into the server. The server runs services, and it's the actual service that's making a response to that client. Here's the thing: when a client is connecting to that service or server, it's connecting to an IP address. But let's say that server goes offline. How is this client going to know that? How is this client going to know that they need to now connect to another server? This could be confusing to this client, and we need a mechanism that solves this.

The Session Problem

We also have another issue, and that is with sessions. When a client machine connects to these servers, it creates what's called a session. This might be a TCP session or an application layer session, whatever the case may be. It's communicating with one of these servers. If it needs to start communicating to another server, then some of that in-session information can get lost if it's not engineered right. So how do we switch this client to point to a new server without losing this session information?

Clustering and Load Balancing

Two possible solutions for these might be clustering and load balancing. It doesn't necessarily solve all of our issues, but this could be part of the solution. Load balancing distributes the load that we have coming into these — how many clients are connecting — and distributes them amongst different servers here. Clustering clusters these servers up into a group that kind of act together, and so they can act all as one service.

An example of load balancing might mean that we set up a separate piece of equipment that is a load balancer, and we'll then route the traffic that comes in from the client to a proper server. Now all this load balancer needs to do is point to another server. We still have the session issue, which maybe we store the session on the backend servers here, on the databases here, so that way it can be persistent as you go from server to server.

Now these two function very differently and serve different purposes. However, because of how they operate, they can solve some of the same problems. So there's a lot of overlap between these, and we may choose clustering, or we might choose load balancing, or we might choose both of them to implement, depending on what our needs are.

About TechKnowSurge

TechKnowSurge builds IT and cybersecurity professionals through hands-on, concept-first training built around real understanding — not memorization. Free interactive tools, structured programs, and 25+ years of real-world experience, all in one place.

Explore free tools and programs →