Creating Deployments with YAML in Kubernetes - Practice Exercises

Challenge - 5 Problems

💻 Command Output

intermediate

Output of kubectl apply with a Deployment YAML

You run kubectl apply -f deployment.yaml with this YAML content:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

What is the expected output of the command?

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

A error: unable to recognize "deployment.yaml"

B pod/myapp created

C service/myapp created

D deployment.apps/myapp created

💡 Hint

Think about what resource type is defined in the YAML and what kubectl reports after applying it.

The YAML defines a Deployment named 'myapp'. When you apply it, kubectl reports 'deployment.apps/myapp created' indicating the Deployment resource was created successfully.

❓ Configuration

intermediate

Correct label selector in Deployment YAML

You want to create a Deployment that manages pods labeled app: frontend. Which selector field in the Deployment spec correctly matches these pods?

A

selector:
  matchLabels:
    app: frontend

B

selector:
  matchLabels:
    app: backend

C

selector:
  matchExpressions:
  - key: app
    operator: NotIn
    values:
    - frontend

D

selector:
  matchLabels:
    tier: frontend

💡 Hint

The selector must exactly match the labels on the pods you want to manage.

The selector must match the pod labels exactly. Since pods have label 'app: frontend', the selector must be 'matchLabels: app: frontend'.

❓ Troubleshoot

advanced

Why does this Deployment fail to create pods?

You apply this Deployment YAML but no pods are created:

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

What is the most likely reason pods are not created?

A The selector labels do not match the pod template labels

B The container image 'busybox' does not exist

C The replicas field must be a string, not a number

D The command field is invalid syntax

💡 Hint

Check if the selector labels and pod labels are exactly the same.

The selector expects pods with label 'app: test' but the pod template has label 'app: test-app'. This mismatch causes no pods to be created.

🔀 Workflow

advanced

Order the steps to update a Deployment image safely

Put these steps in the correct order to update a Deployment's container image with zero downtime:

A 2,1,3,4

B 1,2,4,3

C 1,4,2,3

D 4,1,2,3

💡 Hint

Think about editing first, then applying, then monitoring rollout, then verifying pods.

First edit the YAML to change the image, then apply it. Next monitor rollout status to ensure update success, finally verify pods are running the new image.

✅ Best Practice

expert

Best practice for specifying resource requests in Deployment YAML

Which option shows the best practice for specifying CPU and memory resource requests and limits in a container spec within a Deployment YAML?

A

resources:
  cpu: 500
  memory: 256

B

resources:
  requests:
    cpu: 500m
    memory: 256Mi
  limits:
    cpu: 1
    memory: 512Mi

C

resources:
  requests:
    cpu: "500m"
    memory: "256Mi"
  limits:
    cpu: "1"
    memory: "512Mi"

D

resources:
  requests:
    cpu: 0.5
    memory: 256
  limits:
    cpu: 1
    memory: 512

💡 Hint

Resource values must be strings with units like 'm' for millicores and 'Mi' for memory.

The best practice is to specify resource requests and limits as strings with units, e.g., "500m" for CPU and "256Mi" for memory. This ensures Kubernetes interprets them correctly.

Practice

1. What is the main purpose of a Deployment in Kubernetes when defined using a YAML file?

easy

A. To manage and update multiple copies of an application smoothly

B. To store data persistently across pods

C. To expose an application to the internet

D. To define network policies between pods

Solution

1. Step 1: Understand Deployment role

   A Deployment manages the lifecycle of pods, ensuring the desired number of replicas run and updates happen smoothly.

2. Step 2: Compare options

   Options B, C, and D describe other Kubernetes resources (PersistentVolume, Service, NetworkPolicy), not Deployment.

3. Final Answer:

   To manage and update multiple copies of an application smoothly -> Option A

4. Quick Check:

   Deployment = Manage app replicas and updates [OK]

Hint: Deployments control app copies and updates, not storage or networking [OK]

Common Mistakes:

• Confusing Deployment with Service or PersistentVolume
• Thinking Deployment exposes apps externally
• Assuming Deployment manages network policies

2. Which of the following YAML snippets correctly sets the number of pod replicas to 3 in a Deployment?

easy

A. replicas: 3

B. replicaCount: 3

C. count: 3

D. podReplicas: 3

Solution

1. Step 1: Identify correct replicas field

   The correct field to specify pod count in Deployment YAML is replicas.

2. Step 2: Check other options

   Fields like replicaCount, count, or podReplicas are invalid and will cause errors.

3. Final Answer:

   replicas: 3 -> Option A

4. Quick Check:

   Use 'replicas' to set pod count [OK]

Hint: Use 'replicas' exactly to set pod count in Deployment YAML [OK]

Common Mistakes:

• Using incorrect field names like replicaCount
• Misspelling 'replicas' or using camelCase
• Placing replicas under wrong YAML level

3. Given this Deployment YAML snippet, what will be the label selector used to match pods?

selector:
  matchLabels:
    app: myapp
    tier: frontend

medium

A. Pods with any label app or tier

B. Pods with label app=myapp only

C. Pods with label tier=frontend only

D. Pods with labels app=myapp and tier=frontend

Solution

1. Step 1: Understand matchLabels selector

   The matchLabels requires all listed labels to match exactly for pod selection.

2. Step 2: Analyze given labels

   Both app: myapp and tier: frontend must be present on pods to match.

3. Final Answer:

   Pods with labels app=myapp and tier=frontend -> Option D

4. Quick Check:

   matchLabels means all labels must match [OK]

Hint: matchLabels requires all labels to match exactly [OK]

Common Mistakes:

• Assuming matchLabels matches any one label
• Confusing matchLabels with matchExpressions
• Ignoring one of the labels in selector

4. You wrote this Deployment YAML but your pods are not created. What is the error?

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: webapp
        image: nginx

medium

A. No container ports defined

B. Incorrect apiVersion for Deployment

C. Selector labels do not match template labels

D. Missing container image tag

Solution

1. Step 1: Check selector and template labels

   The selector matchLabels: app: webapp does not match template labels: app: frontend. Labels must match exactly or Deployment creation fails.

2. Step 2: Verify other fields

   Ports are optional for pod creation; apiVersion is correct; image tag defaults to latest.

3. Final Answer:

   Selector labels do not match template labels -> Option C

4. Quick Check:

   Selector must match template labels [OK]

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

Common Mistakes:

• Assuming container ports are required for pod creation
• Thinking image tag is mandatory
• Confusing apiVersion for Deployment

5. You want to update your Deployment to run 5 replicas and change the container image to 'nginx:1.21'. Which YAML snippet correctly applies both changes?

hard

A. spec:
replicas: 5
template:
spec:
containers:
- name: nginx
image: nginx:1.21

B. spec:
replicas: 5
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.21

C. spec:
replicas: 5
containers:
- name: nginx
image: nginx:1.21

D. spec:
template:
spec:
containers:
- name: nginx
image: nginx:1.21
replicas: 5

Solution

1. Step 1: Understand Deployment spec structure

   The replicas field is directly under spec. The pod template is under spec.template, which must include metadata.labels and spec.containers.

2. Step 2: Check each option's correctness

   spec:
     replicas: 5
     template:
       spec:
         containers:
         - name: nginx
           image: nginx:1.21

   misses metadata.labels under template, which is required for selector matching.

   spec:
     replicas: 5
     containers:
     - name: nginx
       image: nginx:1.21

   places containers directly under spec, which is invalid.

   spec:
     template:
       spec:
         containers:
         - name: nginx
           image: nginx:1.21
     replicas: 5

   places replicas after template, which is allowed but missing labels in template metadata.

   spec:
     replicas: 5
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - name: nginx
           image: nginx:1.21

   correctly includes replicas, template metadata labels, and container spec with updated image.

3. Final Answer:

   spec: replicas: 5, template with metadata.labels app: nginx, containers image: nginx:1.21 -> Option B

4. Quick Check:

   replicas under spec, labels in template metadata, containers in template spec [OK]

Hint: Always include labels in template metadata for selector matching [OK]

Common Mistakes:

• Omitting labels in pod template metadata
• Placing containers outside template spec
• Misplacing replicas field