How do gp2 and gp3 performance models differ?

A gp2 volume ties performance to its size. A gp3 volume decouples them. That difference is why the migration can lower EBS cost: you stop buying capacity just to get IOPS.

On gp2, baseline IOPS is 3 IOPS per GiB, with a floor of 100 IOPS for small volumes and a cap at the largest sizes. A 200 GiB volume gets a 600 IOPS baseline. To cover short spikes, gp2 volumes smaller than about 1 TiB can burst to 3,000 IOPS. They draw from a credit bucket that refills at the baseline rate. If the bucket drains under sustained load, the volume drops back to baseline, and latency jumps. Throughput on gp2 also scales with size. Teams often overprovisioned gp2 by hundreds of GiB purely to raise the IOPS or throughput ceiling.

gp3 gives every volume a 3,000 IOPS and 125 MiB/s baseline at any size, with no credits and no burst behaviour. If you need more, you provision additional IOPS and throughput independently, and each is billed as its own line item on top of storage.

Aspect gp2 gp3
Baseline IOPS 3 per GiB, with floor and cap 3,000 at any size
Burst To 3,000 IOPS via credits (under ~1 TiB) None; baseline is sustained
Throughput Scales with volume size 125 MiB/s baseline, provisionable
How you get more performance Grow the volume Provision IOPS/throughput separately

AWS has revised these limits over time. Read the current maximums from the AWS documentation before you size anything.

 gp2: performance coupled to size      gp3: fixed baseline, add-ons billed
+---------------------------+          +-------------------------------+
| Volume size (GiB)         |          | Volume size (GiB)             |
+-------------+-------------+          | billed as storage only        |
              |                        +---------------+---------------+
              v                                        |
+---------------------------+                          v
| Baseline IOPS = 3 x GiB   |          +-------------------------------+
| floor 100 IOPS, cap at top|          | Baseline at any volume size:  |
| 200 GiB -> 600 IOPS       |          |   3,000 IOPS + 125 MiB/s      |
+-------------+-------------+          | no credits, no burst          |
              |                        +---------------+---------------+
              v                                        |
+---------------------------+                          v
| Credit bucket (< ~1 TiB)  |          +-------------------------------+
| refills at baseline rate  |          | Need more? Provision each:    |
+------+-------------+------+          |  + extra IOPS       (billed)  |
       |             |                 |  + extra throughput (billed)  |
       v             v                 +-------------------------------+
+------------+ +------------+
| Burst to   | | Back to    |
| 3,000 IOPS | | baseline,  |
| (credits)  | | latency up |
+------------+ +------------+

 gp2: throughput also scales with size; more performance = bigger volume.
 gp3: performance set independently of size. Check AWS docs for limits.

gp2 derives baseline IOPS and throughput from volume size and relies on a credit bucket to burst, while gp3 gives every volume a fixed 3,000 IOPS and 125 MiB/s baseline with extra IOPS and throughput provisioned and billed separately.

Who benefits from a gp2 to gp3 migration, and when does it lower EBS cost?

The savings come from two separate effects. First, gp3's per-GiB storage price is lower than gp2's, so a volume with the same capacity costs less before you touch performance. Second, gp3 includes 3,000 IOPS and 125 MiB/s at every size. A gp2 volume earns 3 IOPS per GiB, so anything under 1,000 GiB sits below 3,000 IOPS and reaches that level only by spending burst credits. On gp3, the same volume gets 3,000 IOPS as a sustained baseline with no credit bucket to drain.

Prices differ by region and change over time. Look up the current per-GiB, per-provisioned-IOPS, and per-MiB/s rates for your region rather than assuming a fixed percentage saving. Then apply this formula:

monthly saving = GiB × (gp2 $/GiB − gp3 $/GiB) − max(0, IOPS − 3000) × $/IOPS − max(0, MiB/s − 125) × $/MiB/s

Illustrative estimate (assumed numbers, not a benchmark): Assume a 500 GiB volume, a gp2 price of $0.10/GiB-month, and a gp3 price of $0.08/GiB-month. Assume the volume needs no IOPS or throughput above the gp3 baseline, so both extra terms are zero. The saving is 500 × $0.02 = $10 per month for that volume. Across 200 similar volumes, that is $2,000 per month.

Migrate these profiles first:

  • Volumes under 1 TiB whose BurstBalance metric dips. They gain sustained performance and cost less.
  • Boot and root volumes, and dev/test fleets. They are numerous and small, and they rarely need more than baseline performance.
  • Volumes whose observed throughput stays under 125 MiB/s. These need no provisioned add-ons, so the saving is pure storage price.

When should you avoid migrating with default gp3 settings?

  • Large volumes with heavy sequential I/O. On gp2, throughput scales with size: volumes from roughly 334 GiB upward can sustain up to 250 MiB/s. A default gp3 conversion gives 125 MiB/s. Nightly backups, log shipping and analytics scans can take longer after the change, and no error will tell you why.
  • Multi-TiB volumes that rely on size-derived IOPS. gp2 grants 3 IOPS per GiB, up to 16,000, with no separate IOPS charge. A 6 TiB gp2 volume gets 16,000 IOPS. Default gp3 gives it 3,000.

gp3 does not burst. Its provisioned IOPS and throughput are hard ceilings. If you size them too low, the workload is throttled at that limit, so you must provision for observed peaks, not averages.

Illustrative estimate. Assumed prices: gp2 at $0.10/GiB-month; gp3 at $0.08/GiB-month, $0.005 per IOPS-month above 3,000, and $0.04 per MiB/s-month above 125. The volume is 6,144 GiB.

Configuration IOPS Throughput Monthly cost
gp2 16,000 250 MiB/s $614.40
gp3, default settings 3,000 125 MiB/s $491.52
gp3, matched to gp2 16,000 250 MiB/s $561.52 ($491.52 + $65 + $5)

At these prices, matched gp3 is still cheaper. The saving falls from 20% to about 9%. The provisioned add-ons are billed independently of size, so other regional prices or generous headroom can shrink the margin further. Check current pricing for your region before you treat the change as a saving.

How do you size gp3 IOPS and throughput from CloudWatch data?

Pull per-volume metrics from CloudWatch with aws cloudwatch get-metric-statistics, using the Sum statistic and the shortest period the volume reports, typically 60 seconds. VolumeReadOps and VolumeWriteOps are counts per period, not rates. To get IOPS, add the two sums and divide by the period in seconds. Apply the same method to VolumeReadBytes plus VolumeWriteBytes to get bytes per second, then convert that to MiB/s so you can compare it with gp3's throughput setting.

The period matters because a one-hour average can make a volume that peaks at 6,000 IOPS for five minutes look like it runs at 800. A 60-second period still smooths bursts that last only a few seconds. Treat it as a floor and add margin for anything finer than that.

Two other metrics tell you how much to trust the numbers:

  • BurstBalance: If this metric drops well below 100% on a gp2 volume, the workload depends on burst credits. Its measured peak shows what it needs above its baseline, and gp3 has to provision that amount explicitly.
  • VolumeQueueLength: A queue that stays high while IOPS or throughput holds flat at the limit means the volume is already saturated. The observed peak is a ceiling imposed by the volume, not the workload's real demand, so size above it.

Size to the observed peak over a representative window, including batch jobs and month-end runs, plus headroom. Provisioned IOPS and throughput are billed whether you use them or not, so each increment of headroom lowers risk and also gives back part of the savings.

#!/usr/bin/env bash
# Peak IOPS, MiB/s, BurstBalance and queue depth for one EBS volume (GNU date, AWS CLI v2).
set -euo pipefail
VOL="vol-0123456789abcdef0"   # placeholder volume ID
PERIOD=60                      # shortest period the volume reports
# One call returns at most 1,440 datapoints, so 24h at 60s fits. Repeat for longer windows
# that cover batch jobs and month-end runs.
START=$(date -u -d '1 day ago' +%Y-%m-%dT%H:%M:%SZ)
END=$(date -u +%Y-%m-%dT%H:%M:%SZ)

fetch() { # $1 = metric name, $2 = statistic; prints "timestamp value" lines
  aws cloudwatch get-metric-statistics --namespace AWS/EBS --metric-name "$1" \
    --dimensions Name=VolumeId,Value="$VOL" \
    --start-time "$START" --end-time "$END" \
    --period "$PERIOD" --statistics "$2" \
    --query "Datapoints[].[Timestamp,$2]" --output text
}

# Ops and bytes are counts per period, not rates. Add read and write for each
# timestamp, take the largest period, then divide by the period length.
peak_rate() {
  { fetch "$1" Sum; fetch "$2" Sum; } |
    awk -v p="$PERIOD" '{t[$1]+=$2} END {m=0; for (k in t) if (t[k]>m) m=t[k]; print m/p}'
}

IOPS=$(peak_rate VolumeReadOps VolumeWriteOps)
BPS=$(peak_rate VolumeReadBytes VolumeWriteBytes)
echo "peak IOPS:  $IOPS"
awk -v b="$BPS" 'BEGIN {printf "peak MiB/s: %.1f\n", b/1048576}'

# A minimum well below 100 means the gp2 volume relies on burst credits.
echo "lowest BurstBalance (%):"; fetch BurstBalance Minimum | sort -k2 -n | head -1
# A high queue while IOPS or MiB/s sits at the limit means the peak is a ceiling.
echo "highest VolumeQueueLength:"; fetch VolumeQueueLength Average | sort -k2 -nr | head -1

Pulls 60-second CloudWatch sums for one volume, converts the read+write counts to peak IOPS and MiB/s, and checks BurstBalance and VolumeQueueLength before sizing gp3.

How do you perform a volume modification in place with Elastic Volumes?

…you more time before the next change, which matters once the conversion starts.

Use aws ec2 modify-volume with --volume-type gp3 and explicit --iops and --throughput values. Do not rely on defaults. Set the numbers you sized from CloudWatch so the volume's new performance is a decision you made. Track the change with aws ec2 describe-volumes-modifications. Its ModificationState field moves through modifying, optimizing and completed, or failed if something goes wrong.

The volume stays attached and in use the whole time, so you do not need to detach it or stop the instance. During optimizing, though, performance can fall anywhere between the old and new levels, and large volumes can stay in this state for hours. Run big conversions outside peak load.

AWS enforces a cooldown between modifications on the same volume, currently at least six hours. If you size a volume wrong, you either wait out the cooldown or restore from a snapshot. Settle the sizing before you start.

Also check the instance's EBS bandwidth and IOPS limits, for example with aws ec2 describe-instance-types. A volume provisioned above what the instance can deliver adds cost without adding performance.

Roll out in batches:

  1. Non-production volumes and small volumes that depend on burst credits.
  2. Root volumes.
  3. Large or throughput-sensitive data volumes.

After each batch, compare average read and write latency and queue depth against the baseline before you move on.

#!/usr/bin/env bash
# Convert one gp2 volume to gp3 in place and wait for the modification to finish.
set -euo pipefail

VOLUME_ID="vol-0123456789abcdef0"   # placeholder
INSTANCE_TYPE="m5.xlarge"           # type of the instance the volume is attached to
IOPS=4000                            # sized from CloudWatch, not left to defaults
THROUGHPUT=250                       # MiB/s, also sized from CloudWatch

# Check what the instance can deliver. Provisioning above this adds cost, not speed.
aws ec2 describe-instance-types \
  --instance-types "$INSTANCE_TYPE" \
  --query 'InstanceTypes[0].EbsInfo.EbsOptimizedInfo.{BaselineIops:BaselineIops,MaxIops:MaximumIops,BaselineMBps:BaselineThroughputInMBps,MaxMBps:MaximumThroughputInMBps}' \
  --output table

# Request the change with explicit performance values. The volume stays attached.
aws ec2 modify-volume \
  --volume-id "$VOLUME_ID" \
  --volume-type gp3 \
  --iops "$IOPS" \
  --throughput "$THROUGHPUT"

# Poll until the volume leaves the modifying/optimizing states.
# During 'optimizing', performance can sit between the old and new levels.
while true; do
  read -r STATE PROGRESS < <(aws ec2 describe-volumes-modifications \
    --volume-ids "$VOLUME_ID" \
    --query 'VolumesModifications[0].[ModificationState,Progress]' \
    --output text)
  echo "$(date -u +%H:%M:%S) state=$STATE progress=${PROGRESS}%"
  case "$STATE" in
    completed) break ;;
    failed)    echo "Modification failed for $VOLUME_ID" >&2; exit 1 ;;
  esac
  sleep 60
done

A bash script that checks the instance's EBS limits, converts a gp2 volume to gp3 with explicit IOPS and throughput, and polls describe-volumes-modifications until the change completes or fails.

How do you stop new gp2 volumes from being created?

Migrating existing volumes does little if pipelines keep creating gp2 ones. Fix the defaults wherever volumes originate:

  • Terraform: set type = "gp3" with explicit iops and throughput on aws_ebs_volume resources, and set volume_type in root_block_device and ebs_block_device blocks on instances.
  • CloudFormation: set VolumeType: gp3 with Iops and Throughput on AWS::EC2::Volume and in instance block device mappings.
  • Launch templates and AMIs: an AMI's block device mapping carries its own volume type. Override it in the launch template, or rebuild images with gp3 mappings so instances launched without a template also get gp3.
  • Kubernetes: create a StorageClass with provisioner ebs.csi.aws.com and parameters type: gp3, iops and throughput. Mark it as the default. StorageClass parameters cannot be edited after creation, so you need a new class. Existing PersistentVolumes keep their current type.

Always state IOPS and throughput explicitly rather than relying on the gp3 baseline. That makes the sizing decision from your CloudWatch analysis visible in review.

Update IaC before or together with the in-place modifications. If you convert a volume with the CLI while its Terraform or CloudFormation definition still says gp2, the next apply detects drift and modifies the volume back to gp2. The revert is a real volume modification, and it can block the corrective change while the modification cooldown runs.

Updating a shared module or default can produce a plan that touches dozens of volumes at once. Read the full diff before applying. Count the changes, and confirm each one is an in-place update rather than a replace. Also check whether the change triggers instance replacement, for example a launch template change that starts an Auto Scaling instance refresh. Roll out in the same batches you used for the migration.

# New default StorageClass for the EBS CSI driver that provisions gp3.
# StorageClass parameters are immutable, so create a new class rather than
# editing the old gp2 one. Existing PVs keep their current volume type.
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: gp3
  annotations:
    # Make this the cluster default for PVCs that omit storageClassName.
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.aws.com
parameters:
  type: gp3
  # State IOPS and throughput explicitly instead of relying on the gp3
  # baseline, so the sizing decision is visible in code review.
  # Placeholder values: replace with the numbers from your CloudWatch analysis.
  iops: "4000"
  throughput: "250"   # MiB/s
  encrypted: "true"
  csi.storage.k8s.io/fstype: ext4
reclaimPolicy: Delete
# Create the volume in the AZ where the pod is scheduled.
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
# Remove the default flag from the old class so there is only one default:
#   kubectl annotate storageclass gp2 \
#     storageclass.kubernetes.io/is-default-class=false --overwrite

A default Kubernetes StorageClass for the EBS CSI driver that requests gp3 with explicit IOPS and throughput, plus the command to remove the default flag from the old gp2 class.

What are the alternatives to gp3, and what does the migration cost in engineering effort?

The realistic choice for each volume is one of three options. Make it per volume, not per account.

Option When it fits Main trade-off
Stay on gp2 Large volumes where gp3 at matched IOPS and throughput costs more Performance stays tied to size, and the burst credit behavior remains
gp3 with tuned values Most volumes, sized from observed peaks plus headroom Someone owns the provisioned numbers
Provisioned IOPS SSD (io1/io2) Sustained IOPS or latency needs above what gp3 provides Higher cost per IOPS. Justify it with metrics, not a hunch

Before upgrading the volume class, check the instance. Every instance type has its own EBS bandwidth and IOPS ceilings. If the per-instance metrics already sit at those limits, a faster volume changes nothing. A bigger or EBS-optimized instance does. The same applies to gp3: a migration will not fix latency that comes from the instance cap.

The engineering cost has four parts:

  • Metric analysis: pulling CloudWatch data per volume.
  • Per-volume cost comparison: gp2 versus gp3 at the settings you would actually provision.
  • Staged rollout: batching changes and watching each batch.
  • Periodic review: gp3 values do not follow workload growth the way gp2's size-linked baseline did, so they need rechecking as workloads change.

The last part is ongoing. Plan it as recurring work, not a one-time task.

Illustrative estimate (assumed numbers, not a benchmark):

payback_months = (analysis_hours + rollout_hours) × hourly_rate ÷ monthly_savings

Assume 24 analysis hours, 16 rollout hours, a $100 hourly rate and $500 in monthly savings. That gives (24 + 16) × 100 ÷ 500 = 8 months to pay back the work. Add review time per quarter to the cost side before you decide.

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to gp2 to gp3 migration, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • Reviewers see the exact diff and the list of affected services up front, so approval is a decision rather than an investigation.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • Per-service approve/reject means a bad shared value can be refused where it would break something, before it is live.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.