Kubernetes ReplicaSet Basics and a Quick Tutorial

What Is a Kubernetes ReplicaSet? 

A Kubernetes ReplicaSet is a control loop that ensures a specified number of pod replicas are running at any given time. It creates and replaces pods as necessary to maintain the desired state. ReplicaSets provide redundancy and increase availability, ensuring that the desired number of pods are always running, even in the event of node failures or voluntary pod termination.

This is part of a series of articles about Kubernetes architecture.

How Does a ReplicaSet Work and When Should You Use It? 

A ReplicaSet works by maintaining the desired number of replicas of pods defined in its template. If any pods are deleted or terminated, the ReplicaSet will create new ones to replace them and bring the number of replicas back to the desired state. It also monitors the health of existing pods and replaces any that fail or become unresponsive.

ReplicaSets are often used in combination with other Kubernetes objects, such as Deployments, to provide rolling updates and rollbacks, auto-scaling, and rollover of pods with new versions of images. ReplicaSets are also used to provide horizontal scaling of services by allowing administrators to increase or decrease the number of replicas of a given service to meet changing demand.

In general, a ReplicaSet should be used whenever you need to ensure that a specified number of replicas of a pod are running at all times. This makes ReplicaSets useful for stateless applications that can be easily replicated, such as web servers, backend services, and databases.

Tips from the expert

Itiel Shwartz

Co-Founder & CTO

Itiel is the CTO and co-founder of Komodor. He’s a big believer in dev empowerment and moving fast, has worked at eBay, Forter and Rookout (as the founding engineer). Itiel is a backend and infra developer turned “DevOps”, an avid public speaker that loves talking about things such as cloud infrastructure, Kubernetes, Python, observability, and R&D culture.

In my experience, here are tips that can help you better manage and utilize Kubernetes ReplicaSets:

Understand the Use Cases for ReplicaSets

Use ReplicaSets primarily for stateless applications where ensuring a specified number of pod replicas is crucial. For stateful applications, consider using StatefulSets, which offer additional features for managing state.

Combine ReplicaSets with Deployments

Utilize Deployments to manage ReplicaSets. Deployments provide advanced features like rolling updates, rollbacks, and versioning, making it easier to manage application updates and ensure high availability.

Use Labels and Selectors Effectively

Implement a consistent labeling strategy for your pods and ReplicaSets. Effective use of labels and selectors helps in managing and scaling applications efficiently, and simplifies monitoring and troubleshooting.

Monitor ReplicaSet Health

Regularly monitor the health and status of your ReplicaSets using Kubernetes-native tools like kubectl, as well as third-party monitoring solutions. This helps in quickly identifying and resolving issues.

Set Resource Requests and Limits

Define appropriate resource requests and limits for the pods managed by your ReplicaSets. This ensures that pods have sufficient resources and prevents resource contention and overallocation.

Kubernetes ReplicaSet vs. ReplicationController vs. Kubernetes Deployments 

Kubernetes ReplicaSet, ReplicationController, and Deployments are all objects in the Kubernetes system that are used to manage the scaling and availability of pods. However, they have some differences:

ReplicationController 

A ReplicationController is a predecessor to ReplicaSet, and it works similarly to ensure that a specified number of replicas of a pod are running at all times. However, ReplicationControllers do not have some of the advanced features of ReplicaSets, such as label selectors for matching pods and handling updates. ReplicationController was deprecated and replaced by ReplicaSets.

ReplicaSet 

ReplicaSets are an evolution of ReplicationControllers and provide many of the same features for maintaining a specified number of replicas, but with additional features such as label selectors and support for rolling updates. 

ReplicaSets are often used in combination with other Kubernetes objects, such as Deployments, to provide advanced scaling features, such as auto-scaling..

Deployments 

Deployments are higher-level objects that build on ReplicaSets to provide additional features for managing and updating application versions. Deployments allow users to declaratively update applications, and perform rolling updates, rollbacks, and rollovers of pods with new versions of images.

Deployments are the most comprehensive solution for scaling and updating applications in Kubernetes. These objects are well-suited for complex, multi-tier applications that require advanced scaling and updating capabilities.

Kubernetes ReplicaSet Tutorial 

Create a ReplicaSet 

Here’s a basic tutorial on how to create a ReplicaSet in Kubernetes using YAML configuration files. 

Step 1: Define the ReplicaSet object:

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Step 2: Create the ReplicaSet:

$ kubectl apply -f my-rs.yaml

replicaset.apps/my-rs created

 Step 3: Verify the ReplicaSet:

$ kubectl get rs
NAME      DESIRED   CURRENT   READY   AGE
my-rs     3         3         3      10s

Step 4: Verify the pods created by the ReplicaSet:

$ kubectl get pods -l app=my-app
NAME                     READY   STATUS    RESTARTS   AGE
my-rs-5c5f5d5c5c-2vjhx   1/1     Running   0          10s
my-rs-5c5f5d5c5c-jv2x2   1/1     Running   0          10s
my-rs-5c5f5d5c5c-sz7qx   1/1     Running   0          10s

Note: This is just a basic example, in a real-world scenario, you may want to add additional specifications like resource limits, environment variables, volumes, etc.

Scale the Application

Here’s a basic tutorial on how to scale an application using the vim terminal editor and adjusting the replicas property in a ReplicaSet configuration file:

Step 1: Open the ReplicaSet configuration file in the vim terminal editor:

$ vim my-rs.yaml

Step 2: Edit the replicas property to the desired number of replicas:

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-rs
spec:
  replicas: 5 # Change this value to the desired number of replicas
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Step 3: Save and exit the file:

:wq

Step 4: Apply the updated configuration:

$ kubectl apply -f my-rs.yaml
replicaset.apps/my-rs configured

Step 5: Verify the ReplicaSet:

$ kubectl get rs
NAME      DESIRED   CURRENT   READY   AGE
my-rs     5         5         5      10s

Step 6: Verify the pods created by the ReplicaSet:

$ kubectl get pods -l app=my-app
NAME                     READY   STATUS    RESTARTS   AGE
my-rs-5c5f5d5c5c-2vjhx   1/1     Running   0          10s
my-rs-5c5f5d5c5c-jv2x2   1/1     Running   0          10s
my-rs-5c5f5d5c5c-sz7qx   1/1     Running   0          10s
my-rs-5c5f5d5c5c-8vfgh   1/1     Running   0          10s
my-rs-5c5f5d5c5c-9kjhg   1/1     Running   0          10s

This demonstrates how to use the vim terminal editor to edit a ReplicaSet configuration file and scale an application in a Kubernetes cluster.

Kubernetes Operations & Troubleshooting with Komodor

Komodor is the only unified, dev-first Kubernetes Platform, designed to enable Kubernetes across on-prem and cloud-native environments through a single pane of glass. Komodor’s platform empowers developers to confidently operate and troubleshoot their k8s applications while allowing infrastructure teams to maintain control and optimize costs. With immediate visualizations, automated playbooks, and actionable insights, Komodor seamlessly integrates with your existing stack and delivers the right data, with the right context, to the right user. By leveraging Komodor, companies of all sizes significantly improve reliability, productivity, and velocity. Or, to put it simply – Komodor helps you spend less time and resources on managing Kubernetes, and more time on innovating at scale.

To learn more about how Komodor can make it easier to empower you and your teams to troubleshoot and operate K8s, sign up for our free trial.