 In this video, we will see how high availability works for scaled applications on OpenShift, even when a node suddenly goes down. We in the earlier examples, we have seen how the scaling works and how multiple instances of an application run as different parts, right? We'll take the same example and we'll look at how the high availability works. First, we'll start with an application that that's going to fail because it's a single instance that is running. So let's look at the same app like before. It has a front-end DB test and the back-end is a database, right? Each has a single part and the front-end is running on node two and the database is running on node three, right? And we'll also verify the same thing from the command line. For the front-end, we have a single part that is running for front-end. Now, if and this is running on node two and let's also look at what I have on the setup as nodes. I have three nodes here. The master itself is acting as a node and I have node two and node three. Both are in ready state. That means they are running. So I have node two in region primary and it is running in zone east and node three in region primary zone west, right? Now, what we'll try to do and we'll also check to make sure that the application is running. I am clicking on this and there is output so the application is running, right? Now, let us go back and dial. These are these nodes are running on open stack environment. So what I'll do is I'll go back and I'll try to bring down this node to see what happens, right? Node two, I'll go and shut down the, shut out the instance. Now, as the node is shutting down, if I see this application will definitely fail once the node goes down and here is five zero three. Service not available. Now, as there is only, there was only one instance of this application running as a single part when the node on which the pod was running went down. There was no choice. It went and the service is not available. It's obvious, right? Now, let's now try to scale up this application. But before that, I'll start this instance. Now, my part is up and running and the application is again up and running. Let me verify that the node two is now back up and running, right? And then if I check the number of parts, there is a single part running on node two again. Now, let's resize this and scale it up. I'm scaling up to four instances and it is resized. And now I have four instances of this application running. So let's verify that. So I have four parts now. Two of these parts are on node three and two of them are on node two. We've seen that before. Now, if we check if the application is running, it is right. Now, let's try to knock off a node suddenly. I'll go back and I'll shut down. I'm shutting down node two. Now, let's see what happens. I'm trying to check the application as the node is going down. The application continues to run without any issues, even if one of the nodes went down. That's the high availability feature. So OpenShift tries to distribute the parts across the nodes. So even if one of the nodes goes down, the application continues to run without any issues. Not just that. After a little while, OpenShift auto-corrects itself and it will make sure that since the replication controller is asked or asked to run at least four parts at any point of time, it will spin up additional parts on the available node in which in this case it is node three to make sure that the number of parts that we have requested are running. So this happens after a couple of minutes. So let's check if it has already happened. Let me clear the screen and do it again. So now you can see that since node two went down, the replication controller spun up two additional parts on node three itself. Now all there are four parts now and all the four parts are running on node three because that's the available part.