Why advanced patterns matter in Kubernetes - See It in Action

Why Advanced Patterns Matter in Kubernetes

📖 Scenario: You are managing a small web application deployed on Kubernetes. Initially, you used simple deployment patterns, but as your app grows, you notice issues with scaling, updates, and reliability.This project will guide you through creating a Kubernetes Deployment manifest, adding configuration for rolling updates, applying advanced patterns like readiness probes, and finally checking the deployment status.

🎯 Goal: Build a Kubernetes Deployment manifest that uses advanced patterns such as rolling updates and readiness probes to improve application reliability and update safety.

📋 What You'll Learn

Create a basic Deployment manifest with one replica

Add a configuration for rolling update strategy

Add a readiness probe to the container spec

Display the deployment status using kubectl command

💡 Why This Matters

🌍 Real World

Advanced Kubernetes patterns help keep applications running smoothly during updates and scale changes, preventing downtime and improving user experience.

💼 Career

Understanding these patterns is essential for DevOps engineers and site reliability engineers to manage production Kubernetes clusters effectively.

1

Create a basic Deployment manifest

Create a Kubernetes Deployment manifest named webapp-deployment.yaml with apiVersion: apps/v1, kind: Deployment, metadata name webapp, and spec with replicas: 1. The pod template should have a container named webapp-container using image nginx:1.21.

Kubernetes

# Your code here

Hint

Start by defining the Deployment with one replica and a container running nginx version 1.21.

2

Add rolling update strategy configuration

Add a strategy section under spec with type RollingUpdate. Set maxUnavailable to 25% and maxSurge to 25% to control rolling updates.

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 1
  # Add rolling update strategy below
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp-container
        image: nginx:1.21

Hint

Under spec, add strategy with rolling update settings to control how pods update.

3

Add a readiness probe to the container

Inside the container spec, add a readinessProbe that uses an httpGet on path / at port 80. Set initialDelaySeconds to 5 and periodSeconds to 10.

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 1
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 25%
      maxSurge: 25%
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp-container
        image: nginx:1.21
        # Add readinessProbe here

Hint

Add a readiness probe inside the container spec to check if the app is ready by sending HTTP GET requests.

4

Display the deployment status

Run the command kubectl rollout status deployment/webapp to display the rollout status of the webapp deployment.

Kubernetes

# Run the kubectl command below
# Your code here

Hint

Use kubectl rollout status deployment/webapp to check if the deployment is successful and pods are ready.

Practice

1. Why is it important to use advanced patterns in Kubernetes deployments?

easy

A. They reduce the need for monitoring and logging.

B. They make the YAML files shorter but less readable.

C. They improve scalability and reliability of applications.

D. They allow running Kubernetes without any configuration.

Solution

1. Step 1: Understand the role of advanced patterns

   Advanced patterns help manage complex deployments by improving how applications scale and recover from failures.

2. Step 2: Evaluate the options

   Only They improve scalability and reliability of applications. correctly states that advanced patterns improve scalability and reliability, which are key goals in Kubernetes.

3. Final Answer:

   They improve scalability and reliability of applications. -> Option C

4. Quick Check:

   Advanced patterns = better scalability and reliability [OK]

Hint: Think about what helps apps run well at scale [OK]

Common Mistakes:

• Confusing shorter YAML with better patterns
• Assuming no need for monitoring with advanced patterns
• Believing Kubernetes runs without configuration

2. Which of the following is the correct syntax to define a Kubernetes Deployment with a rolling update strategy?

easy

A. apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n type: RollingUpdate\n replicas: 3

B. apiVersion: v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n type: Recreate\n replicas: 3

C. apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n rollingUpdate:\n maxSurge: 1\n maxUnavailable: 0\n replicas: 3

D. apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n replicas: 3

Solution

1. Step 1: Identify correct apiVersion and kind

   Deployments use apiVersion 'apps/v1' and kind 'Deployment'. Options A, C, and D use this correctly.

2. Step 2: Check strategy type for rolling update

   RollingUpdate strategy requires 'strategy.type: RollingUpdate' as in apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n type: RollingUpdate\n replicas: 3. apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n rollingUpdate:\n maxSurge: 1\n maxUnavailable: 0\n replicas: 3 misses 'type' field, so it's incomplete.

3. Final Answer:

   apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n type: RollingUpdate\n replicas: 3 -> Option A

4. Quick Check:

   RollingUpdate strategy syntax = apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: myapp\nspec:\n strategy:\n type: RollingUpdate\n replicas: 3 [OK]

Hint: Look for 'strategy.type: RollingUpdate' in spec [OK]

Common Mistakes:

• Using wrong apiVersion for Deployment
• Missing 'type' under strategy for rolling update
• Confusing Recreate with RollingUpdate strategy

3. Given the following Kubernetes YAML snippet, what will be the result of applying it?

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-deploy
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test
  template:
    metadata:
      labels:
        app: test
    spec:
      containers:
      - name: test-container
        image: nginx:1.19
        ports:
        - containerPort: 80
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

medium

A. Deployment will create 3 pods permanently due to maxSurge setting.

B. Deployment will create 2 pods with rolling update allowing 1 extra pod during updates.

C. Deployment will fail because maxUnavailable cannot be zero.

D. Deployment will create only 1 pod because maxUnavailable is zero.

Solution

1. Step 1: Understand replicas and rolling update settings

   The deployment requests 2 replicas. maxSurge: 1 allows 1 extra pod temporarily during updates, maxUnavailable: 0 means no pods go down during update.

2. Step 2: Analyze the effect on pod count

   During rolling update, Kubernetes can create up to 3 pods (2 + 1 surge) temporarily, but final stable state is 2 pods running.

3. Final Answer:

   Deployment will create 2 pods with rolling update allowing 1 extra pod during updates. -> Option B

4. Quick Check:

   maxSurge=1 means 1 extra pod allowed temporarily [OK]

Hint: maxSurge adds temporary pods, doesn't increase final replicas [OK]

Common Mistakes:

• Thinking maxSurge adds permanent pods
• Believing maxUnavailable cannot be zero
• Confusing maxUnavailable with pod count

4. You applied a Deployment with this strategy:

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxSurge: 2
    maxUnavailable: 2

But during updates, you notice downtime. What is the likely cause?

medium

A. maxUnavailable is too high, allowing pods to be down simultaneously.

B. maxSurge is too low, preventing new pods from starting.

C. RollingUpdate strategy requires maxUnavailable to be zero.

D. Deployment replicas must be at least 5 for this strategy.

Solution

1. Step 1: Understand maxUnavailable impact

   maxUnavailable: 2 means up to 2 pods can be unavailable during update, which can cause downtime if replicas are low.

2. Step 2: Connect downtime to maxUnavailable setting

   If too many pods are down at once, service becomes unavailable, causing downtime.

3. Final Answer:

   maxUnavailable is too high, allowing pods to be down simultaneously. -> Option A

4. Quick Check:

   High maxUnavailable = possible downtime [OK]

Hint: Keep maxUnavailable low to avoid downtime during updates [OK]

Common Mistakes:

• Assuming maxSurge controls downtime
• Believing maxUnavailable must be zero always
• Thinking replicas count must be 5 for rolling updates

5. You want to deploy a microservices app on Kubernetes with zero downtime and automatic rollback on failure. Which advanced pattern combination should you use?

hard

A. Use BlueGreen deployment without readiness or liveness probes.

B. Use Recreate strategy with liveness probes and no rollback settings.

C. Use RollingUpdate strategy without probes and manual rollback.

D. Use RollingUpdate strategy with readiness probes and set 'progressDeadlineSeconds' for rollback.

Solution

1. Step 1: Identify zero downtime and rollback requirements

   RollingUpdate strategy allows gradual pod replacement for zero downtime. Readiness probes ensure traffic only goes to healthy pods. 'progressDeadlineSeconds' triggers rollback if update stalls.

2. Step 2: Evaluate options for best fit

   Use RollingUpdate strategy with readiness probes and set 'progressDeadlineSeconds' for rollback. combines RollingUpdate, readiness probes, and rollback settings, meeting all requirements. Others miss probes or rollback automation.

3. Final Answer:

   Use RollingUpdate strategy with readiness probes and set 'progressDeadlineSeconds' for rollback. -> Option D

4. Quick Check:

   RollingUpdate + readiness probes + rollback = zero downtime + auto rollback [OK]

Hint: Combine RollingUpdate, readiness probes, and rollback for smooth deploys [OK]

Common Mistakes:

• Ignoring readiness probes causing downtime
• Using Recreate strategy which causes downtime
• Skipping rollback configuration