Capacity Planning for Cloud Infra

Why Capacity Planning Matters

Capacity planning is the practice of forecasting when your infrastructure will run out of resources and taking action before that happens. Without it, you face sudden outages, degraded performance, and emergency scrambles to add resources at premium costs.

For businesses running on ServerRaja cloud servers, proactive capacity planning ensures your applications stay responsive as traffic grows, your databases remain fast as data volumes increase, and your team sleeps peacefully knowing the infrastructure can handle what's coming.

The Capacity Planning Cycle

Effective capacity planning follows a continuous cycle:

1. **Measure**: Collect current resource utilization data 2. **Analyze**: Identify trends, patterns, and bottlenecks 3. **Forecast**: Project when resources will be exhausted 4. **Plan**: Determine the scaling strategy and timeline 5. **Execute**: Implement infrastructure changes 6. **Validate**: Verify the changes meet performance targets

Setting Up Metrics Collection

Use Prometheus to collect the metrics you need for capacity planning:

# Key metrics to collect for capacity planning
# CPU utilization per server
# Memory utilization per server
# Disk space usage and growth rate
# Disk IOPS and throughput
# Network bandwidth utilization
# Database connection pool usage
# Request rate and growth
# Response time trends

Create recording rules for capacity metrics:

# /etc/prometheus/rules/capacity-rules.yml
groups:
  - name: capacity-planning
    interval: 5m
    rules:
      # Average CPU usage over 7 days
      - record: instance:cpu_usage:7d_avg
        expr: |
          avg_over_time(
            (1 - avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100
          [7d:5m])

# Average memory usage over 7 days - record: instance:memory_usage:7d_avg expr: | avg_over_time( (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 [7d:5m])

# Disk usage growth rate (GB per day) - record: instance:disk_growth_rate_daily expr: | deriv(node_filesystem_size_bytes{fstype!="tmpfs"} - node_filesystem_avail_bytes{fstype!="tmpfs"}[7d]) * 86400

# Days until disk full - record: instance:disk_days_remaining expr: | node_filesystem_avail_bytes{fstype!="tmpfs"} / (deriv(node_filesystem_size_bytes{fstype!="tmpfs"} - node_filesystem_avail_bytes{fstype!="tmpfs"}[7d]) * 86400) ```

Building Capacity Dashboards

Create a Grafana dashboard for capacity planning with these panels:

# CPU utilization trend (30 days)
avg_over_time(
  (1 - avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100
[30d:1h])

# Memory utilization trend (30 days) avg_over_time( (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 [30d:1h])

# Disk space prediction - days until full predict_linear( node_filesystem_avail_bytes{fstype!="tmpfs"}[30d], 30 * 24 * 3600 ) < 0

# Network bandwidth trend avg_over_time( rate(node_network_receive_bytes_total{device="eth0"}[5m]) * 8 [30d:1h]) ```

Resource Thresholds and Alerts

Define alert thresholds based on your scaling timeline:

# Capacity alerts in Prometheus
groups:
  - name: capacity-alerts
    rules:
      - alert: CPUHighUtilization
        expr: instance:cpu_usage:7d_avg > 70
        for: 1h
        labels:
          severity: warning
        annotations:
          summary: "CPU sustained above 70% on {{ $labels.instance }}"
          description: "Average CPU usage has been {{ $value }}% over 7 days. Plan capacity increase."

- alert: MemoryHighUtilization expr: instance:memory_usage:7d_avg > 80 for: 1h labels: severity: warning annotations: summary: "Memory sustained above 80% on {{ $labels.instance }}"

- alert: DiskSpaceFillingUp expr: instance:disk_days_remaining < 30 for: 1h labels: severity: warning annotations: summary: "Disk on {{ $labels.instance }} will be full in {{ $value }} days"

- alert: DiskSpaceCritical expr: instance:disk_days_remaining < 7 for: 10m labels: severity: critical annotations: summary: "Disk on {{ $labels.instance }} will be full in less than 7 days" ```

Scaling Strategies

Vertical Scaling (Scale Up)

Increase resources on existing servers:

# Check current server resources
cat /proc/cpuinfo | grep processor | wc -l
free -h
df -h

# For cloud servers, resize through the ServerRaja dashboard # Then extend filesystems if needed

# Extend ext4 filesystem sudo resize2fs /dev/vda1

# Extend XFS filesystem sudo xfs_growfs / ```

Horizontal Scaling (Scale Out)

Add more servers behind a load balancer:

# Nginx upstream with auto-scaling awareness
upstream app_cluster {
    least_conn;
    server 10.0.1.10:3000;
    server 10.0.1.11:3000;
    server 10.0.1.12:3000;
    # Add new servers here as traffic grows
}

Database Scaling

# Monitor database connection usage
# PostgreSQL
psql -c "SELECT count(*) as active, max_conn, used/max_conn*100 as pct 
         FROM (SELECT count(*) as used FROM pg_stat_activity) u,
              (SELECT setting::int as max_conn FROM pg_settings WHERE name='max_connections') m
         GROUP BY max_conn, used;"

# Plan read replica deployment when read traffic exceeds 70% of capacity ```

Creating a Capacity Plan Document

Maintain a living capacity plan documenting current state (server specs, utilization, monthly growth trends), projections (30-day and 90-day forecasts with normal and peak scenarios), scaling triggers (CPU > 70% for 7 days, memory > 80%, disk > 75%, connections > 70% pool max), and concrete action items with deadlines.

Cost Optimization

Capacity planning should also optimize costs:

Right-size servers based on actual utilization (not peak estimates)
Use reserved instances or committed use discounts for predictable workloads
Schedule non-production environments to shut down outside business hours
Archive old data to cheaper storage tiers
Clean up unused resources regularly

# Find underutilized servers (average CPU < 10% for 30 days)
# PromQL query for Grafana
avg_over_time(
  (1 - avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100
[30d:1h]) < 10

Conclusion

Capacity planning transforms infrastructure management from reactive firefighting to proactive strategy. Start by setting up Prometheus metrics collection, create capacity dashboards, and define alert thresholds that give you enough lead time to act. Review your capacity plan monthly and before any major traffic event. ServerRaja cloud servers make scaling easy, but planning ahead ensures you scale at the right time and the right size.

Capacity Planning for Growing Cloud Infrastructure: Scale Before You Break