Thank you for joining me for this demo. This is a demo about open shift on OpenStack auto-scaling. To do this, we deployed an open shift. 4.3 environment. We used full stack automation as our method of deployment, and you might know this as ipi. This is great because it gives us the six nodes. Three masters three workers very easily. These nodes are all actually deployed onto OpenStack using a dedicated tenant. This is really cool because the openshift installer creates the OpenStack instances directly for us. We can see them here in horizon, but it does more.

It also builds the networking and everything else you need to get a working openshift install. So, let's see how OpenShift sees this here, we've got our nodes, the three masters and the three workers. These nodes are represented as machines, it's the usual install. We also get a single machine set for the workers and that's important because that's what we need to go ahead and scale our cluster.

Let's start by creating a cluster autoscaler.

You only set one of these and, as it says, it governs the whole cluster. It's easy to edit. You can do it right in the console and this controls the global settings for the entire cluster. Then we need a machine autoscaler to scale the machine set for the workers. This was the same machine set that was created at installation, so you can see the worker up there and we are able to create a symptom limits for this.

So we have a max of 8 and a minimum of 1 meaning there must always be one and a replica, so a minimum of 2 workers, which is actually less than the number of workers we deployed. That's really it so it's time to give it a try and scale OpenShift on OpenStack, of course, to scale we need load. So we're going to do this in a unique project.

So we created an auto scale example project for our testing and we'll use that project to run a special job that generates a lot of high load by creating a lot of busy pods in in this case, we're gonna just bring up a pod that uses a gig of memory, we're gonna run 84 of them, they're gonna run in parallel and then they're gonna die off after five minutes, and that means that once complete, the COTS, the pods will terminate to allow us to see a scale down as well.

So as you can see, we don't have any pods running we're in our special project, no pods running. We need to generate this load, so let's run the scale job. So we run that job that you just saw.

Off it goes and then we can go ahead and look again it with the pods and look at that. We've got 84 load, generating pods being created. So let's see how that's affecting OpenStack instantly the machine set autoscaler is requiring more notes, so we're looking at an OpenStack view and we're seeing OpenStack instances get created. Workers are being built in the underlying infrastructure as a reaction to that, and then we can see this in OpenShift as well have a look at the machines and we see more they're building their provisioning and they're growing.

So as the load continues to increase, the machine set continues to grow the machines up into the limits that we set. Here we go more OpenStack instances are being created, our little are 84 jobs are going nuts there they're really covering everything back in openshift. The process continues and, as you see here, they're their provisioning, they're, building and they're matching in naming. So the naming is consistent across platforms.

There's no difference! You can see that open shift is talking to OpenStack. These are the same instances. The infrastructure is scaling. Our usage is going up. This is horizon from OpenStack, showing V CPU up. We've got more workers, we're scaling we of many many instances, but of course, all good things come to an end and the scaling job ends. So it begins to remove nodes from the Machine set it disables them. It takes them out of circulation. Remember our our jobs are terminating there, they go disappearing. The nodes are going away.

The machines are going away same things happening in OpenStack, the instances of course, the same instances are also being removed, so the OpenStack administrator, seeing it the openshift administrator, is seeing it. We can track this process across the platforms.

Again we see a worker and a worker instance in OpenStack. Then it's gone, and then the system returns to the state that the autoscaler wants it to be in we deployed with three worker nodes. We now have two to match the replica set request we made, and then we have a total of five nodes and eventually everything settles and we're done. That's it. That's open shift on OpenStack auto-scaling, thanks for watching.

You.