 Hello and welcome back to OpenShift 4.x deep dive video series. In the last video, we talked about how ignition process works when a new machine comes up. In this video, we'll talk about machine configurations that can be used to make changes to your machines. Machine configurations are managed by a machine config operator. This is one of the cluster operators a platform operator. Machine configured operator manages a couple of components. One of them is a machine config controller. This controller runs on the master and it coordinates any updates to any machines across your cluster. So if you have to read your machines, that will be managed by your machine config controller. Machine config operator also manages a machine config daemon and this runs as a daemon set across all the nodes on your cluster. Every node will have an instance of machine config daemon running and machine config daemon manages the updates to that particular machine. So machine config controller coordinates with the machine config daemons on individual machines to update machines. Another component that the machine config operator manages is a machine config server and this machine config server is also a daemon set. It runs on the masters. The machine config server hosts the ignition config files. If you were to add some new workers in the future, they need the ignition config files. Those will be served by the machine config server. So machine config is one of the cluster operators and it manages a machine config controller, which is a part it also manages a set of machine config daemons. Every node runs a machine config daemon and there are machine config servers that are running on the master, which provides the ignition config files. Let us now understand machine configurations and machine config pools. Machine configurations are created based on the ignition configuration that we were supplied initially with the bootstrap.ign file. These determine the state of the machine. Machine configuration pools are groups of systems like master, worker, or if you want some specialized machines like infrastructure worker or high performance worker, this form, machine config pools. Let's look at a newly created cluster. When you look for machine config pools, there are two types of machine config pools. This has master pool and a worker pool. The master pool is pointing to a rendered master and the worker pool is pointing to a rendered worker with a hash. Let's look at the machine configs. You'll see a bunch of different machine configurations and you'll also see two special files that are rendered master and rendered worker. We look at one of the machine configuration files and this is a subset of ignition configuration. Machine config controller combines a bunch of machine configs to form a rendered configuration for a particular machine config pool. So for a master it creates a rendered master and for the worker it creates a rendered worker. If you had specialized machine config pools such as high performance work, you will have rendered high performance worker as well. So it combines a bunch of machine configurations to form a rendered file. Multiple rendered rendered machine configurations depending on when you make the changes, it also controller goes and creates a new rendered configuration. So the latest rendered machine configuration is applied to all the machines that belong to that machine config pool. The pool to which a particular machine config applies is based on this label where it says this particular machine config applies to a machine with role worker. Whereas if you look at this other machine configuration, this applies to a master. So the controller combines the machine configurations based on this labeling and applies them. Now let us look at a machine configuration rendered worker. This ends up being a huge file and it has the complete ignition configuration. So what you see under the spec is actually a complete ignition configuration for the worker. So while a rendered machine configuration is delivered as a Kubernetes object by the API server to be applied to the hosts if at all there are any changes in the future. For the first time when you need to create a worker node, then you need an ignition file. A copy of the spec of the rendered machine configuration is also delivered as an ignition configuration file by a machine config server. If you were to create a custom machine configuration pool, let's say we are creating a pool with high performance workers. You may apply your changes as additional machine configs when machine config control pool creates a rendered high performance worker. It combines all the relevant files based on the labeling and it orders them in the alphanumeric sequence so that if there are any files that need to be overridden, file with higher priority of alphanumeric sequence will override the file with lower priority. So if there is a message of the day which is numbered 50 and you also have a message of the day that is numbered 51 with your customizations then 51 will overwrite 50. So let's understand how machine changes or machine upgrades happen. Let's say you go and add some new machine configurations. Machine config controller creates a new rendered machine configuration and that will be delivered via the API server. Machine config controller also identifies the relevant machines and it coordinates the upgrades with the daemons that are running on those boxes. The machine config daemon pulls the rendered machine config that applies to its pool from the API server and it applies those updates to the respective host on which it is running. If the change is an upgrade and if it requires a new release image, a Red Hat Coros image, then the machine config daemon pulls the release image and applies the machine configurations that it pulls from the API server. Now the machine configuration daemon running on a node cordons the node, it drains the parts running on the node, applies the updates based on the machine configuration and reboots that machine. The changes are repeated for all relevant nodes by the respective machine config daemons. So to summarize in this video, we have understood what machine configurations are, what rendered machine configurations are and how custom machine configurations override generic configuration in a rendered machine config and how the machine upgrade works by applying the rendered machine configuration. I hope you enjoyed this video. Thanks a lot for watching.