Vertical Scaling vs Horizontal Scaling – The Complete Guide

Scaling is crucial for handling growing traffic, data, and user demands. Vertical scaling is good for quick performance boosts, while horizontal scaling is the best long-term solution for scalability.

Imagine you own a café, and your business is booming. You need more resources to handle the growing number of customers. You have two choices:

1. Get a bigger, more powerful coffee machine (Vertical Scaling)

2. Get multiple coffee machines and hire more baristas (Horizontal Scaling)

This simple analogy is exactly how scaling works in computing. Let’s dive deeper into these two concepts.

---

What is Vertical Scaling (Scaling Up)?

Vertical scaling means adding more power (CPU, RAM, storage) to an existing server. Instead of adding more machines, you make your current machine stronger.

✅ How it Works?

• You replace your existing server with a higher-capacity one.

• You increase resources like CPU, RAM, or SSD on the same machine.

• It’s like upgrading your laptop from 8GB RAM to 32GB for better performance.

10 Real-Life Examples of Vertical Scaling

Let’s see how vertical scaling works in different scenarios:

1️⃣ Upgrading a Database Server

• A company using MySQL on a small server upgrades it to a higher RAM and CPU server to handle more queries efficiently.

2️⃣ Increasing RAM in a Web Server

• A website experiencing slow load times upgrades its RAM from 8GB to 64GB to handle more users.

3️⃣ Adding More Cores to a CPU

• A machine learning engineer working with AI models moves from a 4-core CPU to a 32-core CPU to speed up computations.

4️⃣ Scaling a Gaming Server

• A gaming company hosting an online multiplayer game upgrades its server’s processing power to reduce lag for players.

5️⃣ Cloud VM Size Upgrade

• A company using AWS EC2 instances upgrades from t2.micro (1GB RAM) to m5.large (8GB RAM) to handle more traffic.

6️⃣ Enhancing Storage Capacity

• An e-commerce site running out of disk space upgrades from 500GB SSD to 4TB SSD to store more product images and user data.

7️⃣ Boosting Performance for Video Rendering

• A video production company increases its workstation’s GPU and RAM to render 4K videos faster.

8️⃣ Upgrading SAP ERP Systems

• A company running SAP ERP software needs faster processing and upgrades its server with high-speed NVMe SSDs and 512GB RAM.

9️⃣ Improving AI Training Performance

• A deep learning startup moves from a single NVIDIA RTX 3080 to an NVIDIA A100 GPU to train AI models faster.

🔟 Enhancing Email Server Performance

• An organization with an email server struggling with 10,000+ users upgrades to a more powerful server with additional RAM and CPU.

Pros & Cons of Vertical Scaling

✅ Pros:

• Simple to implement.

• Requires fewer management efforts.

• No need for code or architecture changes.

❌ Cons:

• Hardware limits: There’s only so much you can upgrade.

• Single point of failure: If the upgraded server crashes, everything goes down.

• Expensive: High-end servers are costly.

---

What is Horizontal Scaling (Scaling Out)?

Horizontal scaling means adding more machines to distribute the load instead of upgrading a single machine.

✅ How it Works?

• Instead of upgrading one powerful machine, you add multiple smaller machines to handle more traffic.

• Think of adding more cashiers in a supermarket instead of replacing one with a super-fast cashier.

• This method ensures high availability and fault tolerance.

10 Real-Life Examples of Horizontal Scaling

Let’s see how horizontal scaling is used:

1️⃣ Adding More Web Servers

• An e-commerce website under heavy traffic adds more web servers behind a load balancer to distribute requests.

2️⃣ Scaling a Database with Read Replicas

• A company with high read requests in MySQL creates multiple read replicas to handle database queries.

3️⃣ Using Kubernetes Pods for Microservices

• A microservices-based application scales up by increasing the number of Kubernetes pods to handle more user requests.

4️⃣ Expanding Cloud Storage Systems

• A cloud storage provider like Google Drive adds more storage servers instead of upgrading a single large disk.

5️⃣ Scaling a Content Delivery Network (CDN)

• A video streaming platform (like Netflix) distributes content across multiple edge servers worldwide to reduce latency.

6️⃣ Adding More Cache Nodes

• A company using Redis or Memcached adds more caching nodes instead of increasing memory on a single cache server.

7️⃣ Increasing Load Balanced Servers

• A social media platform uses a load balancer to distribute requests across multiple web servers.

8️⃣ Handling IoT Devices at Scale

• A company collecting IoT data from millions of sensors distributes the load across thousands of processing nodes.

9️⃣ Scaling AI Model Inference

• A chatbot serving millions of users runs on multiple AI inference servers instead of a single powerful one.

🔟 Expanding an Email System

• Instead of upgrading a single email server, a company distributes email requests across multiple mail servers.

Pros & Cons of Horizontal Scaling

✅ Pros:

• No hardware limits: Easily add more machines.

• Fault tolerance: If one machine fails, others take over.

• Cost-effective: Use multiple smaller, cheaper machines.

❌ Cons:

• More complex: Needs load balancing and distributed architecture.

• Higher maintenance: More machines mean more monitoring.

• Code changes required: Some applications may need refactoring to support horizontal scaling.

---

When to Choose Vertical vs Horizontal Scaling?

---

Vertical Scaling in Kubernetes – Examples with Tests and Outputs

In Kubernetes (K8s), Vertical Scaling means increasing the CPU, memory, or other resources of a pod instead of adding more replicas. This is done using the Vertical Pod Autoscaler (VPA) or by manually updating the resource limits.

Let's explore 10 examples of vertical scaling in Kubernetes, along with test steps and how to observe the output.

---

Example 1: Increasing CPU Requests & Limits for a Pod

Scenario

A web application pod is experiencing slow performance under load. We increase its CPU requests and limits to improve performance.

Steps

1. Deploy a simple Nginx pod with low CPU allocation:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx
      image: nginx
      resources:
        requests:
          cpu: "100m"
        limits:
          cpu: "200m"

1. Apply the YAML file:

kubectl apply -f nginx-pod.yaml

1. Check the current resource allocation:

kubectl describe pod nginx-pod | grep -i cpu

1. Output:

Requests:
  cpu: 100m
Limits:
  cpu: 200m

1. Increase CPU allocation:

resources:
  requests:
    cpu: "500m"
  limits:
    cpu: "1000m"

1. Reapply the configuration and check again:

kubectl apply -f nginx-pod.yaml
kubectl describe pod nginx-pod | grep -i cpu

1. New Output:

Requests:
  cpu: 500m
Limits:
  cpu: 1000m

How to Observe the Effect?

• Use HPA (Horizontal Pod Autoscaler) to see if the pod handles more load efficiently.

• Monitor the CPU usage using:

kubectl top pod nginx-pod

• Output (shows CPU consumption increasing as it scales up):

NAME        CPU(cores)   MEMORY(bytes)  
nginx-pod   450m        100Mi  

---

Example 2: Increasing Memory for a Stateful Database Pod

Scenario

A MySQL database pod is running out of memory. We increase the memory allocation to prevent crashes.

Steps

1. Deploy a MySQL pod with low memory limits:

apiVersion: v1
kind: Pod
metadata:
  name: mysql-pod
spec:
  containers:
    - name: mysql
      image: mysql
      env:
        - name: MYSQL_ROOT_PASSWORD
          value: "password"
      resources:
        requests:
          memory: "256Mi"
        limits:
          memory: "512Mi"

1. Apply the YAML file:

kubectl apply -f mysql-pod.yaml

1. Check memory allocation:

kubectl describe pod mysql-pod | grep -i memory

1. Output:

Requests:
  memory: 256Mi
Limits:
  memory: 512Mi

1. Increase memory allocation:

resources:
  requests:
    memory: "1Gi"
  limits:
    memory: "2Gi"

1. Reapply and verify:

kubectl apply -f mysql-pod.yaml
kubectl describe pod mysql-pod | grep -i memory

1. New Output:

Requests:
  memory: 1Gi
Limits:
  memory: 2Gi

How to Observe the Effect?

• Monitor memory usage:

kubectl top pod mysql-pod

• Output:

NAME        CPU(cores)   MEMORY(bytes)  
mysql-pod   150m        850Mi  

---

Example 3: Auto-Tuning Resources with Vertical Pod Autoscaler (VPA)

Scenario

We want Kubernetes to automatically adjust CPU and memory for a workload based on real-time usage.

Steps

1. Install VPA (if not already installed):

kubectl apply -f https://github.com/kubernetes/autoscaler/releases/latest/download/vertical-pod-autoscaler.yaml

1. Deploy a sample pod and enable VPA:

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: nginx-vpa
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind: Deployment
    name: nginx-deployment
  updatePolicy:
    updateMode: "Auto"

1. Apply and check VPA recommendations:

kubectl describe vpa nginx-vpa

1. Output:

Recommendation:
  Target:
    CPU: 600m
    Memory: 1Gi

How to Observe the Effect?

• Watch for automatic updates in pod allocation:

kubectl describe pod nginx-pod

• Monitor VPA logs:

kubectl logs -l app=nginx --tail=50

---

Example 4: Increasing Storage for a StatefulSet (PostgreSQL)

Scenario

A PostgreSQL database pod is running out of disk space. We increase its PersistentVolume (PV) storage.

Steps

1. Check existing storage allocation:

kubectl get pvc

1. Output:

NAME            STATUS   VOLUME   CAPACITY   ACCESS MODES
postgres-pvc   Bound    pvc-xyz  5Gi        RWO

1. Modify the PersistentVolumeClaim (PVC) size:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

1. Apply and verify:

kubectl apply -f postgres-pvc.yaml
kubectl get pvc

1. New Output:

NAME            STATUS   VOLUME   CAPACITY   ACCESS MODES
postgres-pvc   Bound    pvc-xyz  10Gi       RWO

How to Observe the Effect?

• Run df -h inside the PostgreSQL pod to see updated storage:

kubectl exec -it postgres-pod -- df -h

• Output:

Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb1       10G   2G    8G   20% /var/lib/postgresql/data

---

Final Thoughts - Vertical scaling

Vertical scaling is useful when you need more power per node instead of adding more pods. In Kubernetes, this means increasing CPU, memory, or storage for a single pod.

🚀 Key Takeaways:

• Manual Scaling: Modify resources.requests and resources.limits.

• Automated Scaling: Use Vertical Pod Autoscaler (VPA) for dynamic adjustments.

• Persistent Storage Scaling: Modify PersistentVolumeClaims (PVCs) for stateful applications.

---

Horizontal Scaling in Kubernetes – Examples with Tests and Outputs

Horizontal Scaling in Kubernetes involves increasing the number of pod replicas to handle increased load. This ensures high availability and better performance without overloading a single pod. Horizontal scaling is typically managed using Horizontal Pod Autoscaler (HPA) or by manually adjusting the replicas count in a Deployment, ReplicaSet, or StatefulSet.

Now, let's explore 10 examples of horizontal scaling, with step-by-step Kubernetes tests and how to verify the results.

---

Example 1: Manually Scaling a Deployment

Scenario

A web application is running with one pod. We need to increase the number of replicas to handle more traffic.

Steps

1. Create a Deployment with a single pod:

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

1. Apply the Deployment:

kubectl apply -f nginx-deployment.yaml

1. Verify the number of running pods:

kubectl get pods -l app=nginx

1. Output:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-5fd6d7f95c-abcde   1/1     Running   0          30s

1. Scale the Deployment to 5 replicas:

kubectl scale deployment nginx-deployment --replicas=5

1. Verify the new number of pods:

kubectl get pods -l app=nginx

1. New Output:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-5fd6d7f95c-abcde   1/1     Running   0          1m
nginx-deployment-5fd6d7f95c-fghij   1/1     Running   0          5s
nginx-deployment-5fd6d7f95c-klmno   1/1     Running   0          5s
nginx-deployment-5fd6d7f95c-pqrst   1/1     Running   0          5s
nginx-deployment-5fd6d7f95c-uvwxy   1/1     Running   0          5s

Observations

• More pods are now running, distributing the load.

• The application can now handle 5x more traffic than before.

---

Example 2: Auto-Scaling Pods Based on CPU Usage

Scenario

We want Kubernetes to automatically scale the number of pods based on CPU usage.

Steps

1. Enable Metrics Server (if not already installed):

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

1. Deploy an application and expose it via a service:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: cpu-load-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cpu-load
  template:
    metadata:
      labels:
        app: cpu-load
    spec:
      containers:
        - name: cpu-load
          image: vish/stress
          args:
            - "--cpu"
            - "1"
          resources:
            requests:
              cpu: "100m"
            limits:
              cpu: "500m"

1. Apply the Deployment:

kubectl apply -f cpu-load-deployment.yaml

1. Create an HPA to scale pods when CPU exceeds 50% usage:

kubectl autoscale deployment cpu-load-deployment --cpu-percent=50 --min=1 --max=10

1. Check the HPA status:

kubectl get hpa

1. Output:

NAME                  REFERENCE                         TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
cpu-load-deployment   Deployment/cpu-load-deployment   60%/50%   1         10        3          1m

1. Verify the number of running pods:

kubectl get pods -l app=cpu-load

1. Output (HPA added 2 new pods due to CPU load):

NAME                                READY   STATUS    RESTARTS   AGE
cpu-load-deployment-abcde           1/1     Running   0          1m
cpu-load-deployment-fghij           1/1     Running   0          10s
cpu-load-deployment-klmno           1/1     Running   0          10s

Observations

• The number of pods increased automatically when CPU usage went above 50%.

• The system can now dynamically adjust to varying loads.

---

Example 3: Horizontal Scaling StatefulSets (MongoDB Replica Set)

Scenario

A MongoDB StatefulSet needs to scale from 1 replica to 3 to improve database redundancy and availability.

Steps

1. Deploy a StatefulSet with 1 replica:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb
spec:
  serviceName: mongodb
  replicas: 1
  selector:
    matchLabels:
      app: mongodb
  template:
    metadata:
      labels:
        app: mongodb
    spec:
      containers:
        - name: mongodb
          image: mongo

1. Apply the StatefulSet:

kubectl apply -f mongodb-statefulset.yaml

1. Check the running pods:

kubectl get pods -l app=mongodb

1. Output:

NAME         READY   STATUS    RESTARTS   AGE
mongodb-0    1/1     Running   0          1m

1. Scale the StatefulSet to 3 replicas:

kubectl scale statefulset mongodb --replicas=3

1. Verify the new pods:

kubectl get pods -l app=mongodb

1. Output:

NAME         READY   STATUS    RESTARTS   AGE
mongodb-0    1/1     Running   0          2m
mongodb-1    1/1     Running   0          10s
mongodb-2    1/1     Running   0          10s

Observations

• More replicas of the MongoDB instance are running.

• The application benefits from high availability and fault tolerance.

---

Final Thoughts Horizontal scaling

Horizontal scaling in Kubernetes is essential for handling increasing traffic and improving application resilience.

🚀 Key Takeaways:

• Manual Scaling: Use kubectl scale to increase/decrease replicas.

• Auto Scaling: Use HPA to adjust pod count based on CPU or memory usage.

• Stateful Scaling: Scale StatefulSets carefully to maintain database integrity.

---

Conclusion

Scaling is crucial for handling growing traffic, data, and user demands. Vertical scaling is good for quick performance boosts, while horizontal scaling is the best long-term solution for scalability and resilience.

🚀 If you are starting small, vertical scaling is an easy fix. But if you expect massive growth, horizontal scaling is the way forward!

---