Kubernetes Deployments

A comprehensive skill for working with Kubernetes Deployments, the declarative way to manage application updates, scaling, and rollbacks in Kubernetes clusters.

What This Skill Does

This skill helps you create, manage, and troubleshoot Kubernetes Deployments. You'll learn to:

Create Deployments with proper manifest structure

Perform rolling updates and rollbacks

Scale applications horizontally

Monitor Deployment status and health

Apply best practices for production workloads

Instructions

Step 1: Understand Deployment Basics

A Deployment provides declarative updates for Pods and ReplicaSets. Key concepts:

**Desired state**: The configuration you define in YAML/JSON

**Current state**: The actual running state of your application

**Reconciliation**: Kubernetes continuously works to match current state to desired state

**Rolling updates**: Zero-downtime updates by gradually replacing old Pods

**Rollback**: Revert to a previous Deployment version if issues occur

Step 2: Create a Basic Deployment

When creating a Deployment manifest:

```yaml

apiVersion: apps/v1

kind: Deployment

metadata:

name: <app-name>

labels:

app: <app-label>

spec:

replicas: 3

selector:

matchLabels:

app: <app-label>

template:

metadata:

labels:

app: <app-label>

spec:

containers:

- name: <container-name>

image: <image:tag>

ports:

- containerPort: <port>

```

Apply the Deployment:

```bash

kubectl apply -f deployment.yaml

```

Verify the Deployment:

```bash

kubectl get deployments

kubectl get pods -l app=<app-label>

kubectl describe deployment <app-name>

```

Step 3: Update a Deployment (Rolling Update)

To update the container image:

```bash

kubectl set image deployment/<app-name> <container-name>=<new-image:tag>

```

Or edit the manifest and reapply:

```bash

kubectl apply -f deployment.yaml

```

Monitor the rollout:

```bash

kubectl rollout status deployment/<app-name>

kubectl get pods -w

```

Step 4: Configure Rolling Update Strategy

Add update strategy to your Deployment spec:

```yaml

spec:

strategy:

type: RollingUpdate

rollingUpdate:

maxSurge: 1 # Maximum Pods over desired count

maxUnavailable: 0 # Maximum Pods unavailable during update

```

`maxSurge`: Extra Pods created during update (can be number or percentage)

`maxUnavailable`: How many Pods can be unavailable (0 for zero-downtime)

Step 5: Rollback a Deployment

View rollout history:

```bash

kubectl rollout history deployment/<app-name>

```

Rollback to previous version:

```bash

kubectl rollout undo deployment/<app-name>

```

Rollback to specific revision:

```bash

kubectl rollout undo deployment/<app-name> --to-revision=<number>

```

Step 6: Scale a Deployment

Scale imperatively:

```bash

kubectl scale deployment/<app-name> --replicas=<number>

```

Or update the manifest and reapply:

```yaml

spec:

replicas: 5

```

Verify scaling:

```bash

kubectl get deployment <app-name>

kubectl get pods -l app=<app-label>

```

Step 7: Add Health Checks

Configure liveness and readiness probes in the container spec:

```yaml

spec:

containers:

- name: <container-name>

image: <image:tag>

livenessProbe:

httpGet:

path: /healthz

port: 8080

initialDelaySeconds: 30

periodSeconds: 10

readinessProbe:

httpGet:

path: /ready

port: 8080

initialDelaySeconds: 5

periodSeconds: 5

```

**Liveness probe**: Restarts container if unhealthy

**Readiness probe**: Removes Pod from Service endpoints if not ready

Step 8: Set Resource Requests and Limits

Define resource constraints:

```yaml

spec:

containers:

- name: <container-name>

image: <image:tag>

resources:

requests:

memory: "64Mi"

cpu: "250m"

limits:

memory: "128Mi"

cpu: "500m"

```

This ensures proper scheduling and prevents resource exhaustion.

Step 9: Troubleshoot Deployment Issues

Common troubleshooting commands:

```bash

Check Deployment status

kubectl get deployment <app-name>

View Deployment events

kubectl describe deployment <app-name>

Check Pod status

kubectl get pods -l app=<app-label>

View Pod logs

kubectl logs -l app=<app-label>

Check ReplicaSet status

kubectl get rs -l app=<app-label>

Describe a specific Pod

kubectl describe pod <pod-name>

```

Common issues:

Image pull errors: Check image name, tag, and registry credentials

CrashLoopBackOff: Check application logs and liveness probes

Insufficient resources: Check node capacity and resource requests

Selector mismatch: Ensure selector matches Pod template labels

Step 10: Apply Best Practices

**Labels and Selectors:**

Use consistent labeling (app, version, component, tier)

Ensure selector matches Pod template labels exactly

**Update Strategy:**

Set `maxUnavailable: 0` for zero-downtime updates

Configure appropriate `maxSurge` based on cluster capacity

Use `minReadySeconds` to slow rollouts and catch issues early

**Resource Management:**

Always define resource requests and limits

Use PodDisruptionBudgets for critical applications

Set appropriate replica counts for high availability

**Health Checks:**

Implement both liveness and readiness probes

Set realistic `initialDelaySeconds` for application startup

Use HTTP probes for web applications, exec probes for others

**Version Control:**

Keep Deployment manifests in version control

Use `--record` flag to track rollout history (deprecated but useful)

Tag container images with semantic versions, not `latest`

Examples

**Example 1: Create an nginx Deployment**

```bash

kubectl create deployment nginx --image=nginx:1.25 --replicas=3

kubectl expose deployment nginx --port=80 --type=LoadBalancer

kubectl get all -l app=nginx

```

**Example 2: Update with rolling strategy**

```bash

kubectl set image deployment/nginx nginx=nginx:1.26

kubectl rollout status deployment/nginx

kubectl rollout history deployment/nginx

```

**Example 3: Rollback after failed update**

```bash

kubectl rollout undo deployment/nginx

kubectl rollout status deployment/nginx

```

Constraints

Deployments are designed for stateless applications (use StatefulSets for stateful workloads)

Pod template changes trigger new rollouts; changing other fields does not

Selector is immutable after Deployment creation

Scaling to zero removes all Pods but keeps the Deployment object

Rollout history is limited by `revisionHistoryLimit` (default: 10)

Additional Resources

Official Kubernetes Deployments documentation: https://kubernetes.io/docs/concepts/workloads/controllers/deployment/

Use `kubectl explain deployment` for inline documentation

Consider using Helm or Kustomize for complex Deployment management

Enable HorizontalPodAutoscaler (HPA) for automatic scaling based on metrics

Kubernetes Deployments

Kubernetes Deployments

What This Skill Does

Instructions

Step 1: Understand Deployment Basics

Step 2: Create a Basic Deployment

Step 3: Update a Deployment (Rolling Update)

Step 4: Configure Rolling Update Strategy

Step 5: Rollback a Deployment

Step 6: Scale a Deployment

Step 7: Add Health Checks

Step 8: Set Resource Requests and Limits

Step 9: Troubleshoot Deployment Issues

Check Deployment status

View Deployment events

Check Pod status

View Pod logs

Check ReplicaSet status

Describe a specific Pod

Step 10: Apply Best Practices

Examples

Constraints

Additional Resources

Reviews (0)