ReplicaSet definition in Kubernetes - Step-by-Step Execution

Process Flow - ReplicaSet definition

Write ReplicaSet YAML

↓

kubectl apply -f

↓

API Server receives request

↓

ReplicaSet Controller checks desired replicas

↓

Create/Delete Pods to match replicas

↓

Pods running as per ReplicaSet spec

↓

Monitor and maintain pod count

The flow shows how a ReplicaSet YAML is applied, the controller ensures the desired number of pods run, creating or deleting pods as needed.

Execution Sample

Kubernetes

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: nginx
        image: nginx:1.21

This YAML defines a ReplicaSet named 'my-rs' that ensures 3 pods with label 'app: myapp' running nginx container.

Process Table

Step	Action	Evaluation	Result
1	kubectl apply -f replicaset.yaml	YAML parsed and sent to API Server	ReplicaSet object created in cluster
2	ReplicaSet Controller reads ReplicaSet spec	Desired replicas = 3	Checks current pods with label 'app: myapp'
3	Current pods found = 0	0 < 3	Create 3 pods matching template
4	Pods start running	Pods Ready status checked	3 pods running and ready
5	Controller monitors pods	If pod deleted or fails	Creates replacement pod to maintain 3
6	User deletes one pod manually	Pods now 2	Controller creates 1 new pod to restore 3
7	User updates replicas to 5	Desired replicas = 5	Controller creates 2 more pods
8	Pods running = 5	Desired replicas met	Stable state maintained
9	User deletes ReplicaSet	ReplicaSet removed	Pods controlled by ReplicaSet are deleted
10	No ReplicaSet present	No controller managing pods	Pods remain or are deleted depending on owner references

💡 ReplicaSet ensures pod count matches desired replicas; stops when ReplicaSet is deleted.

Status Tracker

Variable	Start	After Step 3	After Step 6	After Step 7	Final
desired_replicas	3	3	3	5	5
current_pods	0	3	2	4	5
ReplicaSet_exists	Yes	Yes	Yes	Yes	No

Key Moments - 3 Insights

Why does the controller create pods when current pods are less than desired replicas?

Because the ReplicaSet controller constantly compares current pods with desired replicas (see execution_table step 3). If current pods are fewer, it creates new pods to match the desired count.

What happens if a pod managed by ReplicaSet is deleted manually?

The controller detects the missing pod and creates a new one to maintain the desired replicas (see execution_table step 6).

What occurs when the ReplicaSet is deleted?

Deleting the ReplicaSet removes its control over pods, which usually leads to deletion of those pods as well (see execution_table step 9 and 10).

Visual Quiz - 3 Questions

Look at the execution table, at which step does the controller create pods for the first time?

A Step 3

B Step 5

C Step 6

D Step 7

💡 Hint

Check the 'Action' and 'Result' columns in step 3 where pods are created because current pods are less than desired.

According to the variable tracker, what is the number of current pods after step 6?

A 3

B 2

C 4

D 5

💡 Hint

Look at the 'current_pods' row under 'After Step 6' column.

If the desired replicas were changed to 4 instead of 5 at step 7, how would the current pods count change after step 7?

A It would be 3

B It would be 4

C It would be 5

D It would remain 2

💡 Hint

The controller creates pods to match desired replicas; see variable_tracker and execution_table step 7.

Concept Snapshot

ReplicaSet YAML defines desired pod count and selector.
Apply YAML with kubectl to create ReplicaSet.
Controller ensures pods match desired replicas.
Creates or deletes pods automatically.
Deleting ReplicaSet removes pod management.

Full Transcript

A ReplicaSet in Kubernetes is defined by a YAML file specifying the desired number of pod replicas and a selector to identify pods it manages. When you apply this YAML using kubectl, the ReplicaSet object is created in the cluster. The ReplicaSet controller continuously monitors the current number of pods matching the selector. If fewer pods exist than desired, it creates new pods using the pod template. If pods are deleted or fail, the controller replaces them to maintain the desired count. Changing the replicas count in the ReplicaSet spec causes the controller to add or remove pods accordingly. When the ReplicaSet is deleted, it stops managing pods, which are usually deleted as well. This process ensures your application always has the right number of pods running.

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