Understanding Kubernetes YAML: Structure, Templates, Labels, and Selectors

 Today, focus on one common YAML structure, then learn what changes between Pod, ReplicaSet, Deployment, and DaemonSet. Don't try to memorize four YAML files separately.

1. First understand the universal Kubernetes YAML structure

Almost every Kubernetes manifest starts like this:

apiVersion:
kind:
metadata:
spec:

🧠 Remember: AKMS

ApiVersion → Kind → Metadata → Spec

Think:

What API? → What object? → What is its name? → What should it do?

---

2. Pod YAML

Start with the simplest one.

apiVersion: v1
kind: Pod

metadata:
  name: nginx-pod

spec:
  containers:
    - name: nginx-container
      image: nginx

Understand it like this:

Pod YAML
│
├── apiVersion: v1
│
├── kind: Pod
│
├── metadata
│   └── name: nginx-pod
│
└── spec
    └── containers
        └── nginx-container
            └── image: nginx

What do you need to remember?

Only this:

apiVersion: v1
kind: Pod

metadata:
  name: <pod-name>

spec:
  containers:
    - name: <container-name>
      image: <image>

The Pod directly contains containers.

---

3. ReplicaSet YAML

Now things become one level deeper.

apiVersion: apps/v1
kind: ReplicaSet

metadata:
  name: nginx-rs

spec:
  replicas: 3

  selector:
    matchLabels:
      app: nginx

  template:
    metadata:
      labels:
        app: nginx

    spec:
      containers:
        - name: nginx-container
          image: nginx

Don't memorize this entire file.

Understand the structure:

ReplicaSet
│
├── metadata
│   └── name
│
└── spec
    │
    ├── replicas
    │
    ├── selector
    │
    └── template
        │
        ├── metadata
        │   └── labels
        │
        └── spec
            └── containers
                └── image

⭐ Most important concept

A ReplicaSet creates Pods.

Therefore, it needs a Pod template.

That's why you see:

spec:
  template:

And inside the template:

metadata:
  labels:
    app: nginx

spec:
  containers:
    - name: nginx-container
      image: nginx

---

4. Deployment YAML

Deployment is very similar to ReplicaSet.

apiVersion: apps/v1
kind: Deployment

metadata:
  name: nginx-deployment

spec:
  replicas: 3

  selector:
    matchLabels:
      app: nginx

  template:
    metadata:
      labels:
        app: nginx

    spec:
      containers:
        - name: nginx-container
          image: nginx

Look carefully.

Compare:

Deployment
    ↓
ReplicaSet
    ↓
Pod
    ↓
Container
    ↓
Image

The Deployment YAML contains a Pod template, just like the ReplicaSet.

The big thing to remember

Deployment:

spec:
  replicas:
  selector:
  template:

And inside template:

metadata:
  labels:

spec:
  containers:

---

5. DaemonSet YAML

DaemonSet is also similar.

apiVersion: apps/v1
kind: DaemonSet

metadata:
  name: nginx-daemon

spec:
  selector:
    matchLabels:
      app: nginx

  template:
    metadata:
      labels:
        app: nginx

    spec:
      containers:
        - name: nginx-container
          image: nginx

Notice something?

DaemonSet doesn't normally need:

replicas:

Because its purpose is different.

It basically says:

Run a Pod on each eligible Node.

---

6. The BIG pattern you should memorize

This is the most important part of today's lesson.

Pod

Pod
 ↓
Container
 ↓
Image

YAML:

spec:
  containers:

---

ReplicaSet

ReplicaSet
 ↓
Pod Template
 ↓
Container
 ↓
Image

YAML:

spec:
  replicas:
  selector:
  template:
    metadata:
    spec:
      containers:

---

Deployment

Deployment
 ↓
ReplicaSet
 ↓
Pod
 ↓
Container
 ↓
Image

YAML still contains:

spec:
  replicas:
  selector:
  template:
    metadata:
    spec:
      containers:

The Deployment creates/manages ReplicaSets, which manage Pods.

---

DaemonSet

DaemonSet
 ↓
Pod
 ↓
Container
 ↓
Image

YAML:

spec:
  selector:
  template:
    metadata:
    spec:
      containers:

---

7. Your master YAML template

Instead of memorizing four files, memorize this:

apiVersion: <version>
kind: <object>

metadata:
  name: <name>

spec:
  <object-specific configuration>

  template:
    metadata:
      labels:
        app: <label>

    spec:
      containers:
        - name: <container-name>
          image: <image>

But remember:

Pod does NOT have template.

Pod:

spec:
  containers:

Controllers such as Deployment, ReplicaSet and DaemonSet use:

spec:
  template:

because they need to describe what Pod they should create.

---

8. Why is template there?

This is extremely important.

Suppose you say:

replicas: 3

Kubernetes needs to know:

"What should those 3 Pods look like?"

You provide that answer here:

template:

For example:

template:
  metadata:
    labels:
      app: nginx

  spec:
    containers:
      - name: nginx
        image: nginx

Meaning:

Create Pods that look like this.

So:

ReplicaSet
     │
     │ replicas: 3
     ↓
  Template
     │
     ├── Pod 1
     ├── Pod 2
     └── Pod 3

---

9. Why do we have labels and selector?

This is another important concept.

You have:

selector:
  matchLabels:
    app: nginx

And:

template:
  metadata:
    labels:
      app: nginx

They match:

Selector                 Pod Label
   ↓                         ↓
app: nginx   ←────────→   app: nginx

The controller uses this relationship to know which Pods belong to it.

🧠 Easy memory

Selector = "Which Pods am I responsible for?"

Labels = "What label does this Pod have?"

---

10. One picture to remember everything

                 Kubernetes YAML
                       │
        ┌──────────────┴──────────────┐
        │                             │
       Pod                         Controllers
        │                             │
        │                  ┌──────────┼──────────┐
        │                  │          │          │
        │             ReplicaSet  Deployment  DaemonSet
        │                  │          │          │
        │                  └──────────┼──────────┘
        │                             │
        │                         template
        │                             │
        └──────────────┬──────────────┘
                       ↓
                      Pod
                       ↓
                   containers
                       ↓
                     image

---

11. Your memory trick for today

Remember AKMS:

A → apiVersion
K → kind
M → metadata
S → spec

Then remember:

Pod

S → containers

spec:
  containers:

Controllers

S → selector → template → containers

spec:
  selector:
  template:
    metadata:
    spec:
      containers:

And Deployment/ReplicaSet additionally have:

replicas:

DaemonSet generally doesn't need replicas because it works per eligible Node.

---

12. The four YAMLs side-by-side

Resource	Main purpose	Important spec
Pod	Run container(s)	containers
ReplicaSet	Maintain number of Pods	replicas, selector, template
Deployment	Manage ReplicaSets/Pods and rollouts	replicas, selector, template
DaemonSet	Run a Pod on eligible Nodes	selector, template

Your one-line mental model

Pod = Container
ReplicaSet = Number of Pods
Deployment = Manage ReplicaSets + updates
DaemonSet = Pod on each eligible Node

If you understand apiVersion → kind → metadata → spec → template → containers → image, you don't need to blindly memorize YAML. You can build it yourself.