ReplicaSet definition in Kubernetes - Commands & Configuration

Introduction

A ReplicaSet in Kubernetes makes sure a specific number of copies of a pod are running at all times. It helps keep your app available by replacing pods if they fail or get deleted.

When you want to keep a fixed number of identical pods running to handle user requests.

When you need to automatically replace pods that crash or are deleted.

When you want to scale the number of pods up or down easily.

When you want to manage pods without manually restarting them.

When you want to ensure high availability of your application.

Config File - replicaset.yaml

replicaset.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: example-replicaset
  labels:
    app: example-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example-app
  template:
    metadata:
      labels:
        app: example-app
    spec:
      containers:
      - name: example-container
        image: nginx:1.23.3
        ports:
        - containerPort: 80

apiVersion: Specifies the Kubernetes API version.

kind: Defines this resource as a ReplicaSet.

metadata: Contains the name and labels to identify the ReplicaSet.

spec.replicas: Number of pod copies to run.

spec.selector: Matches pods with these labels to manage.

spec.template: Defines the pod template used to create pods, including container image and ports.

Commands

This command creates the ReplicaSet in the Kubernetes cluster using the configuration file. It tells Kubernetes to start managing 3 pods with the specified settings.

Terminal

kubectl apply -f replicaset.yaml

Expected Output

replicaset.apps/example-replicaset created

This command lists all ReplicaSets in the current namespace to verify that the ReplicaSet was created and shows how many pods are ready.

Terminal

kubectl get replicasets

Expected Output

NAME                DESIRED   CURRENT   READY   AGE

example-replicaset   3         3         3       10s

This command lists all pods with the label app=example-app to check that the ReplicaSet created the pods correctly.

Terminal

kubectl get pods -l app=example-app

Expected Output

NAME                          READY   STATUS    RESTARTS   AGE

example-replicaset-abc123     1/1     Running   0          15s

example-replicaset-def456     1/1     Running   0          15s

example-replicaset-ghi789     1/1     Running   0          15s

→

-l - Filter pods by label

This command shows detailed information about the ReplicaSet, including events and pod status, to understand how it is managing pods.

Terminal

kubectl describe replicaset example-replicaset

Expected Output

Name:           example-replicaset

Namespace:      default

Selector:       app=example-app

Labels:         app=example-app

Replicas:       3 current / 3 desired

Pods Status:    3 Running / 0 Waiting / 0 Succeeded / 0 Failed

Events:

  Type    Reason             Age   From                   Message

  ----    ------             ----  ----                   -------

  Normal  SuccessfulCreate   1m    replicaset-controller  Created pod: example-replicaset-abc123

  Normal  SuccessfulCreate   1m    replicaset-controller  Created pod: example-replicaset-def456

  Normal  SuccessfulCreate   1m    replicaset-controller  Created pod: example-replicaset-ghi789

Key Concept

If you remember nothing else from this pattern, remember: a ReplicaSet keeps the exact number of pod copies running by creating or deleting pods automatically.

Common Mistakes

Not matching the selector labels with the pod template labels

The ReplicaSet won't manage any pods if the selector does not match the pod labels, so no pods will be created or controlled.

Ensure the selector.matchLabels exactly matches the labels in spec.template.metadata.labels.

Setting replicas to zero unintentionally

This causes the ReplicaSet to delete all pods, making the app unavailable.

Set replicas to the desired number of pods you want running, usually at least 1.

Summary

Create a ReplicaSet with a YAML file defining the desired number of pod copies and pod template.

Apply the ReplicaSet configuration using kubectl apply to start managing pods.

Verify the ReplicaSet and pods with kubectl get and kubectl describe commands.

Ensure selector labels match pod labels so the ReplicaSet can manage pods correctly.

Practice

1. What is the main purpose of a ReplicaSet in Kubernetes?

easy

A. To manage network policies between pods

B. To store persistent data for pods

C. To ensure a specified number of pod replicas are running at all times

D. To schedule pods on specific nodes

Solution

1. Step 1: Understand ReplicaSet role

   A ReplicaSet's job is to keep a stable set of pod replicas running.

2. Step 2: Compare options with ReplicaSet function

   Only To ensure a specified number of pod replicas are running at all times describes maintaining pod replicas, which is the ReplicaSet's purpose.

3. Final Answer:

   To ensure a specified number of pod replicas are running at all times -> Option C

4. Quick Check:

   ReplicaSet manages pod count = A [OK]

Hint: ReplicaSet = keeps pods running in set number [OK]

Common Mistakes:

• Confusing ReplicaSet with PersistentVolume
• Thinking ReplicaSet manages network policies
• Mixing ReplicaSet with pod scheduling

2. Which of the following is the correct minimal YAML snippet to define a ReplicaSet with 3 replicas?

easy

A. apiVersion: apps/v1\nkind: ReplicaSet\nmetadata:\n name: my-rs\nspec:\n replicas: 3\n selector:\n matchLabels:\n app: myapp\n template:\n metadata:\n labels:\n app: myapp\n spec:\n containers:\n - name: nginx\n image: nginx

B. apiVersion: v1\nkind: ReplicaSet\nmetadata:\n name: my-rs\nspec:\n replicas: 3\n selector:\n app: myapp\n template:\n metadata:\n labels:\n app: myapp\n spec:\n containers:\n - name: nginx\n image: nginx

C. apiVersion: apps/v1\nkind: ReplicaSet\nmetadata:\n name: my-rs\nspec:\n replicas: three\n selector:\n matchLabels:\n app: myapp\n template:\n metadata:\n labels:\n app: myapp\n spec:\n containers:\n - name: nginx\n image: nginx

D. apiVersion: apps/v1\nkind: ReplicaSet\nmetadata:\n name: my-rs\nspec:\n replicas: 3\n selector:\n matchLabels:\n app: myapp\n template:\n metadata:\n labels:\n app: otherapp\n spec:\n containers:\n - name: nginx\n image: nginx

Solution

1. Step 1: Check apiVersion and kind

   ReplicaSet requires apiVersion: apps/v1 and kind: ReplicaSet. The option with apiVersion: v1 is invalid.

2. Step 2: Validate replicas and selector-template match

   Replicas must be an integer like 3, not string 'three'. Selector labels must match template labels exactly (one option has template app: otherapp mismatch). Only one option has all correct: apps/v1, replicas: 3, matching labels with proper structure.

3. Final Answer:

   Correct YAML with apiVersion apps/v1, replicas: 3, matching selector and template labels -> Option A

4. Quick Check:

   YAML syntax + matching labels = D [OK]

Hint: Match selector labels exactly with template labels [OK]

Common Mistakes:

• Using wrong apiVersion
• Setting replicas as string instead of number
• Mismatching selector and template labels

3. Given this ReplicaSet YAML snippet, what will be the number of pods running after applying it?

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: test-rs
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test
  template:
    metadata:
      labels:
        app: test
    spec:
      containers:
      - name: busybox
        image: busybox
        command: ['sleep', '3600']

medium

A. 3 pods

B. 1 pod

C. 0 pods

D. 2 pods

Solution

1. Step 1: Check replicas field

   The spec.replicas is set to 2, so Kubernetes will try to run 2 pods matching the selector.

2. Step 2: Confirm selector and template labels match

   Selector matches label app: test, and template labels also have app: test, so pods will be created.

3. Final Answer:

   2 pods -> Option D

4. Quick Check:

   replicas = 2 pods running [OK]

Hint: replicas number = pods running if labels match [OK]

Common Mistakes:

• Ignoring label selector and template label matching
• Assuming pods run without matching labels
• Confusing replicas with container count

4. You applied a ReplicaSet YAML but no pods are created. Which of these is the most likely cause?

medium

A. The replicas field is set to 0

B. The selector labels do not match the pod template labels

C. The container image name is misspelled

D. The ReplicaSet name is missing

Solution

1. Step 1: Understand pod creation depends on selector matching template labels

   If selector labels don't match pod template labels, ReplicaSet won't manage any pods.

2. Step 2: Evaluate other options

   Replicas 0 means no pods, but question says pods expected. Misspelled image causes pod crash, not zero pods. Name missing causes YAML error, not silent no pods.

3. Final Answer:

   The selector labels do not match the pod template labels -> Option B

4. Quick Check:

   Selector-template label mismatch = no pods [OK]

Hint: Selector and template labels must match exactly [OK]

Common Mistakes:

• Assuming image typo prevents pod creation
• Ignoring selector-template label mismatch
• Thinking ReplicaSet name is optional

5. You want to update a ReplicaSet to increase replicas from 2 to 5 but keep the same pods running without downtime. What is the best approach?

hard

A. Scale the ReplicaSet using kubectl scale command to 5 replicas

B. Delete the ReplicaSet and create a new one with replicas: 5

C. Edit the ReplicaSet YAML to set replicas: 5 and apply it

D. Change the pod template labels to new values and apply

Solution

1. Step 1: Understand scaling ReplicaSet

   Scaling with kubectl scale updates replicas live without downtime.

2. Step 2: Evaluate other options

   Editing YAML and applying works but less safe than scale command. Deleting ReplicaSet causes downtime. Changing labels breaks pod matching.

3. Final Answer:

   Scale the ReplicaSet using kubectl scale command to 5 replicas -> Option A

4. Quick Check:

   Use kubectl scale for live replica changes [OK]

Hint: Use kubectl scale to change replicas live [OK]

Common Mistakes:

• Deleting ReplicaSet causes downtime
• Changing labels breaks pod matching
• Editing YAML directly risks errors