What are Replicas in Kubernetes

Replicas in Kubernetes are essentially copies of Pods. By creating multiple replicas of a Pod, Kubernetes can ensure that a specified number of identical Pods are running at any given moment. This not only boosts the availability of your application but also facilitates load balancing and redundancy.

Replication of Pods

In the world of Kubernetes, the act of duplicating Pods is commonly referred to as replication. The primary function of a ReplicaSet is to maintain a stable set of replica Pods running at any given time.

Self-healing Capabilities

One of the remarkable features of Kubernetes is its self-healing mechanisms. A ReplicaSet ensures that a Pod or a set of Pods are always up and running. When a Pod dies, the ReplicaSet automatically creates a new Pod to keep the desired number of replicas constant. This self-healing process enhances the reliability and durability of applications running on Kubernetes.

Automated Placement and Maintenance of Replicas

Kubernetes automates the placement and maintenance of replicas through a ReplicaSet, based on the specifications defined in the spec. It is this spec that determines how many replicas should exist at any given time. When the actual state does not match the desired state, Kubernetes works to reconcile the difference.

Dynamic Definition of Pod Numbers

The Kubernetes ecosystem is dynamic and robust. It allows you to scale the number of Pods up or down depending on the need. This feature is known as Horizontal Autoscaling, and it enables the system to handle increases or decreases in load by dynamically adjusting the number of running Pods.

Defining a ReplicaSet with YAML

Kubernetes uses YAML for its object definitions, including those for ReplicaSets.

YAML Configuration for HelloWorld ReplicaSet

The first step to creating a ReplicaSet in Kubernetes is to define the configuration in a YAML file. In this configuration, we specify the metadata (like name and labels), the desired number of replicas, the selector that defines how the ReplicaSet identifies its constituents, and the Pod template which includes the details about the Pod.

Here's an example of a simple YAML file that defines a ReplicaSet named helloworld:

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: helloworld
  labels:
    app: helloworld
spec:
  replicas: 2
  selector:
    matchLabels:
      app: helloworld
  template:
    metadata:
      labels:
        app: helloworld
    spec:
      containers:
      - name: helloworld
        image: gcr.io/google-samples/hello-app:1.0

This YAML file defines a ReplicaSet of two Pods, each running the helloworld container.

Starting Minikube

Before we can start deploying our ReplicaSets, we need to ensure Minikube is up and running. Start Minikube using the command below.

$ minikube start

Launching a Pod as a ReplicaSet

Once the YAML file is ready, we can create the ReplicaSet using the kubectl apply command, which applies the configuration to the cluster. Here's how we launch the helloworld ReplicaSet:

$ kubectl apply -f replicaset.yaml

Let's confirm Pods.

$ kubectl get pods

NAME               READY   STATUS    RESTARTS   AGE
helloworld-4bf2r   1/1     Running   0          42s
helloworld-ssttm   1/1     Running   0          42s

Two hellowrold Pods have been created.

Listing ReplicaSets

After launching the ReplicaSet, we can confirm its creation by listing all ReplicaSets in the current namespace:

$ kubectl get replicaset

NAME         DESIRED   CURRENT   READY   AGE
helloworld   2         2         2       3m12s

This command will return a list of all the ReplicaSets, including our newly created helloworld ReplicaSet.

Scaling Up the ReplicaSet

Kubernetes allows for easy scaling of applications. To increase the number of replicas in our helloworld ReplicaSet, we can use the kubectl scale command:

$ kubectl scale --replicas=5 replicaset/helloworld

replicaset.apps/helloworld scaled

This command updates the helloworld ReplicaSet to have five replicas. Kubernetes will create additional Pods to match the new desired state.

Testing the Self-healing Mechanism

Kubernetes is built with robust self-healing mechanisms which are inherent in its design. A critical feature of Kubernetes ReplicaSets is their ability to ensure that a specific number of replica Pods are running at any given moment. If a Pod in a ReplicaSet dies or is deleted, the ReplicaSet will automatically create a new one to replace it.

Terminating a Pod

To test this, let's terminate a Pod from our helloworld ReplicaSet and observe what happens. The kubectl delete pod command can be used to delete a specific Pod. Replace POD_ID with the ID of one of the Pods from the helloworld ReplicaSet.

$ kubectl delete pod POD_ID # In my case, POD_ID is helloworld-4bf2r for instance

pod "helloworld-4bf2r" deleted

Verifying Auto-generation of a New Pod

Now, let's check the state of our Pods. As Kubernetes realizes that one Pod is missing from the ReplicaSet, it should have automatically created a new one to maintain the desired number of replicas.

$ kubectl get pods

NAME               READY   STATUS    RESTARTS   AGE
helloworld-55kgl   1/1     Running   0          105s
helloworld-5kkdg   1/1     Running   0          105s
helloworld-drmmv   1/1     Running   0          9s
helloworld-n7sg9   1/1     Running   0          105s
helloworld-ssttm   1/1     Running   0          5m21s

Running this command should show that a new Pod has been created to replace the one that was deleted. This shows the self-healing capability of Kubernetes, ensuring that your services remain available and resilient to failures. This feature is of great importance, especially for production environments where high availability and reliability are crucial.

Cleanup

Once you have finished your testing, it's good practice to clean up your environment to free up resources and maintain a tidy working space.

To remove the helloworld ReplicaSet that we created earlier, we can use the kubectl delete command along with the -f flag followed by the name of the configuration file. This will delete the ReplicaSet and all the Pods associated with it.

$ kubectl delete -f replicaset.yaml

Running this command will stop and remove all Pods maintained by the helloworld ReplicaSet. By practicing regular cleanup, you can ensure your Kubernetes environment is always ready for your next experiment or deployment.