Amazon EBS (Elastic Block Store) volumes are billed based on two primary factors:

• Provisioned storage size (in GB-month)
• Volume type (gp3, io1, st1, etc.)

The billing occurs in per-second increments, with a minimum of 60 seconds for any provisioned EBS volume. This means even if you delete a volume after just 20 minutes, you'll be charged for the full hour of usage.

For your specific scenario with a 100GiB gp3 volume:

Volume size: 100 GiB
Duration: 20 minutes
Region: us-east-1 (example)
Price: $0.10 per GB-month

Calculation:
(100 GB * $0.10) / (730 hours/month) * 1 hour = ~$0.0137

Even though you only used it for 20 minutes, you'll be charged for the full hour (minimum billing unit). The charge would be approximately $0.0137, not $10, because:

• EBS doesn't charge full month price for short usage
• The $10/month figure is what you'd pay for keeping the volume running continuously

You won't see immediate charges because:

• Amazon accumulates usage throughout the month
• Final calculation occurs at the end of the billing cycle
• Small charges may not be visible in the cost explorer until they aggregate

To programmatically check your EBS usage:

aws cloudwatch get-metric-statistics \
  --namespace AWS/EBS \
  --metric-name VolumeUsage \
  --dimensions Name=VolumeId,Value=vol-1234567890abcdef0 \
  --start-time $(date -d "-1 hour" +%Y-%m-%dT%TZ) \
  --end-time $(date +%Y-%m-%dT%TZ) \
  --period 3600 \
  --statistics Average

For cost tracking, set up AWS Budgets:

aws budgets create-budget \
  --account-id 123456789012 \
  --budget file://budget.json

Example budget.json:

{
  "BudgetName": "EBS-Monthly-Limit",
  "BudgetLimit": {
    "Amount": "50",
    "Unit": "USD"
  },
  "CostFilters": {
    "Service": "Amazon Elastic Block Store"
  }
}

• Set up CloudWatch alarms for unexpected volume creation
• Use AWS Organizations SCPs to limit volume sizes in dev accounts
• Implement automated cleanup scripts for temporary resources

Example cleanup script (Python with Boto3):

import boto3
from datetime import datetime, timedelta

def clean_old_volumes(max_age_hours=1):
    ec2 = boto3.client('ec2')
    response = ec2.describe_volumes(Filters=[{'Name': 'status', 'Values': ['available']}])
    
    cutoff = datetime.now() - timedelta(hours=max_age_hours)
    for volume in response['Volumes']:
        create_time = volume['CreateTime'].replace(tzinfo=None)
        if create_time < cutoff:
            print(f"Deleting volume {volume['VolumeId']} created at {create_time}")
            ec2.delete_volume(VolumeId=volume['VolumeId'])

if __name__ == "__main__":
    clean_old_volumes()

Amazon EBS (Elastic Block Store) uses hourly billing with minute-level granularity. When you provision an EBS volume, you're charged for each hour the volume exists, rounded up to the nearest hour. The billing clock starts from the moment you create the volume until you delete it.

For your case of creating a 100 GiB gp2 volume (standard SSD) and deleting it after 20 minutes:

Volume Type: gp2
Size: 100 GiB
Region: us-east-1
Duration: 20 minutes

At current pricing ($0.10 per GB-month for gp2 in us-east-1), your calculation would be:

Hourly rate = (100 GB * $0.10) / (24 hours * 30 days) ≈ $0.0139 per hour
Charge = 1 hour (minimum) * $0.0139 ≈ $0.0139

AWS billing operates on a delayed cycle. You typically won't see charges for several hours (or until the next day) because:

• Usage records take time to propagate through AWS systems
• Billing data is aggregated before appearing in your account
• The AWS Cost Explorer updates with a 24-48 hour delay

Here's how to check your EBS costs using AWS CLI:

aws ce get-cost-and-usage \
    --time-period Start=2023-01-01,End=2023-01-31 \
    --granularity MONTHLY \
    --metrics "UnblendedCost" \
    --group-by Type=DIMENSION,Key=SERVICE \
    --filter '{"Dimensions": {"Key": "USAGE_TYPE", "Values": ["EBS:VolumeUsage.gp2"]}}'

To avoid unexpected charges from temporary volumes:

# Use AWS Lambda to automatically delete volumes after testing
import boto3

def lambda_handler(event, context):
    ec2 = boto3.client('ec2')
    volumes = ec2.describe_volumes(Filters=[{'Name': 'tag:Temp', 'Values': ['true']}])
    for vol in volumes['Volumes']:
        ec2.delete_volume(VolumeId=vol['VolumeId'])

Set up CloudWatch alarms for unexpected EBS spending:

aws cloudwatch put-metric-alarm \
    --alarm-name "HighEBSUsage" \
    --metric-name "EstimatedCharges" \
    --namespace "AWS/Billing" \
    --statistic "Maximum" \
    --period 21600 \
    --evaluation-periods 1 \
    --threshold 50 \
    --comparison-operator "GreaterThanThreshold" \
    --dimensions Name=Currency,Value=USD