- Controllers are the brain behind Kubernetes.
- Replication Controller is the focus here.
- What is a replica and why do we need a replication controller?
- What if an application crashes and the pod fails?
- The users are then no longer able to access the application.
- We need more than one instance of a pod running at the same time.
- The Replication Controller helps us run multiple instances of a pod in a Kubernetes cluster. This provides High Availability.
- A Replication Controller is useful even for a single pod, as it can bring up a new pod if the existing one fails.
- The Replication Controller ensures the specified number of pods are running at all times.
- Another use of the Replication Controller is Load Balancing and Scaling.
- If a number of issues increases, we can increase the pod count to balance the load.
- If demand continues to increase and the resources of the first node are exhausted, can then deploy to another node in the cluster.
- There are two similar terms:
Replication Controller and Replica Set
Replication Controller is the older technology, that is being replaced by Replica Set. What was discussed previously is applicable to both of those technologies.- How to create a
Replication Controller
- Create a
Replication Controller definition file.
- 4 sections:
- apiVersion: v1 - Replication Controllers are supported in v1.
- kind: ReplicationController
- metadata: myapp-rc
- labels:
* app: myapp
* type: front-end
- spec:
* template:
- For any Kubernetes Definition File, the
spec: defines what is inside the object.
- The
Replication Controller creates multiple instances of a pod.
- The
template: section is used to create replicas.
- How do we define the
pod template:?
- Can reuse the contents of a
pod definition file in the template section.
- Can move all of the lines, aside from
apiVersion and kind.
- The
Replication Controller is the parent in the file and the Pod Definition being the child.
- We need to mention how many replicas are required in the
Replication Controller.
- Add the property called
replicas: to the file.
template: and replicas: are children of the spec section.
- Once complete, run
kubectl create -f rc-definition.yaml. It then creates the Replication Controller.
- To view the
Replication Controllers, run the kubectl get replicationcontroller
- Will observe the amount of replicas in the output.
- Then to check the pods that were created by the
Replication Controller, run the kubectl get pods command.
- All of the pods will start with the name of the
Replication Controller
- To view the created
Replication Controllers, run kubectl get replicationcontroller
- Now we look at
replicaset.
- Very similar to the
replicationcontroller.
- We have
apiVersion, kind, metadataand spec
apiversion however is set to app/v1- If you input that incorrectly, you will likely receive an error that looks like this:
kind is ReplicaSet- Add
name and labels in the metadata section.
spec is the same as ReplicationController- The main difference is that
ReplicaSet requires a selector definition.
- The
selector part helps the ReplicaSet identify which pods fall under it.
- Why do you need to specify the pods that are underneath it though?
- A
ReplicaSet can also manage pods, which were not part of the ReplicaSet creation.
- For example, pods created before the
ReplicaSet, which matched labels.
- The
ReplicaSet will also take those pods into consideration, when creating the replicas.
- The
selector is one of the major differences between ReplicationController and ReplicaSet.
- The
selector is not a required field for the ReplicationController.
- When skipped, the
ReplicationController assumes it is the same as the labels provided in the pod definition file.
- In the case of
ReplicaSet, a user input is required for this property.
- That is done using
matchLabels
matchLabels specifies everything under it, to the labels on the pods.
- The
ReplicaSet also provides other options for matching labels, that are not available in the ReplicationController.
- To create a
ReplicaSet, run the kubectl create command, providing the ReplicaSet as input.
- To view the created replicas, run the
kubectl get replicaset command.
- Of course for pods, run
kubectl get pods
- Regarding
Labels and Selectors - why do we label objectes in Kubernetes?
- For example, the front-end web app is deployed as 3 pods.
- If they are not created, the replicaset will create them for you.
- The role of the replicaset is that if any of the pods fail, it creates new ones.
- The replicaset is a process that monitors the pods.
- How does the replicaset know which pods to monitor.
- Labelling the pods during creation is necessary.
- The labels provided are a filter for the replicaset.
- The same concept of labels and connectors is used throughout Kubernetes.
- In the
replicaset-definition.yml, there are 3 sections there.
- In the above example, need to create a Replicaset to ensure the 3 pods are up at all times.
- When a new ReplicaSet instance is created, it is not going to automatically create a new POD pod, because there are already 3 available.
- In that case, we always need a
template section, in case a pod fails in the future.
- How to Scale a ReplicaSet - going from 3 –> 6 as an example.
- To do this, update the number of replicas in the definition file to
6
- Then use
kubectl replace to update the replica set.
kubectl replace -f replicaset-definition.yml
- A second way to perform the same task, is via the
kubectl scale command and provide the number of replicas to scale to.
kubectl scale --replicas=6 -f replicaset-definition.yml
- Can either put the definition file or the replicaset name in the
Type / Name format.
- Using the filename as input, will not automatically update all replicas in the file. The
replicaset-definition.yml will still be 3.
- There are options to scale the replicas based on load as well.
kubectl create -f replicaset-definition.yml creates the replicaset.kubectl get replicaset to show the replicasets created.kubectl delete replicaset myapp-replicaset will get rid of all of the replicasets. It also deletes all of the underlying pods as well.kubectl replace -f replicaset-definition.yml to increase the amount of replicas via modifying the file.kubectl scale -replicas=6 -f replicaset-definition.yml will scale the replicas, without modifying the yml file.