← Back

Consumption Model Optimization

This steering file provides comprehensive guidance for adopting a consumption model aligned with the AWS Well-Architected Cost Optimization Pillar's second design principle: Adopt a Consumption Model.

Core Principle

Pay only for what you use by implementing dynamic scaling, rightsizing resources, and leveraging usage-based pricing models to optimize costs while maintaining performance.

Key Components

Dynamic Resource Scaling

• **Auto Scaling**: Automatically adjust capacity based on demand
• **Serverless architectures**: Use services that scale to zero when not in use
• **Elastic workloads**: Design applications to scale up and down efficiently
• **Demand-based provisioning**: Provision resources based on actual usage patterns

Rightsizing Optimization

• **Performance monitoring**: Continuously monitor resource utilization
• **Capacity optimization**: Match resource capacity to actual requirements
• **Instance type optimization**: Use the most cost-effective instance types
• **Storage optimization**: Use appropriate storage classes and sizes

Usage-Based Pricing

• **On-Demand resources**: Use for variable and unpredictable workloads
• **Reserved capacity**: Commit to consistent usage for discounts
• **Spot instances**: Use spare capacity for fault-tolerant workloads
• **Savings Plans**: Flexible commitment-based pricing

Workflow 1: Rightsizing Analysis & Implementation

Goal: Identify and implement rightsizing opportunities across all compute resources

Steps:

1. Analyze Current Resource Utilization

   Use compute_optimizer to identify:
   - Overprovisioned instances
   - Underprovisioned instances
   - Optimal instance type recommendations
   - Performance impact assessments

2. Get Detailed Optimization Recommendations

   Use cost_optimization to discover:
   - EC2 rightsizing opportunities
   - EBS volume optimization
   - Lambda function optimization
   - Auto Scaling group recommendations

3. Analyze Cost Impact

   Use rec_details for specific recommendations:
   - Expected cost savings
   - Performance implications
   - Implementation complexity
   - Risk assessment

Example Rightsizing Implementation:

// Step 1: Get comprehensive rightsizing recommendations
const rightsizingRecs = usePower("aws-cost-optimization", "aws-billing-cost-management", "compute_optimizer", {
  "operation": "get_ec2_instance_recommendations",
  "filters": "{\"finding\": [\"Overprovisioned\", \"Underprovisioned\"]}"
})

// Step 2: Focus on high-impact, low-risk recommendations
const highImpactRecs = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_optimization", {
  "operation": "list_recommendations",
  "filters": "{\"resourceTypes\": [\"Ec2Instance\"], \"implementationEfforts\": [\"VeryLow\", \"Low\"], \"actionTypes\": [\"Rightsize\"]}"
})

// Step 3: Get detailed analysis for top recommendation
const detailedAnalysis = usePower("aws-cost-optimization", "aws-billing-cost-management", "rec_details", {
  "recommendation_id": highImpactRecs[0].recommendationId
})

// Step 4: Analyze current usage patterns to validate recommendations
const usageAnalysis = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
  "operation": "getCostAndUsage",
  "start_date": "2024-11-01",
  "end_date": "2024-12-01",
  "granularity": "DAILY",
  "group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"USAGE_TYPE\"}]",
  "filter": "{\"And\": [{\"Dimensions\": {\"Key\": \"SERVICE\", \"Values\": [\"Amazon Elastic Compute Cloud - Compute\"], \"MatchOptions\": [\"EQUALS\"]}}, {\"Dimensions\": {\"Key\": \"USAGE_TYPE_GROUP\", \"Values\": [\"EC2: Running Hours\"], \"MatchOptions\": [\"EQUALS\"]}}]}",
  "metrics": "[\"UsageQuantity\"]"
})

Workflow 2: Auto Scaling Optimization

Goal: Implement and optimize auto scaling to match capacity with demand

Steps:

1. Analyze Auto Scaling Group Performance

   Use compute_optimizer to evaluate:
   - Auto Scaling group configurations
   - Scaling policy effectiveness
   - Instance type recommendations
   - Performance optimization opportunities

2. Assess Current Scaling Patterns

   Use getCostAndUsage to understand:
   - Usage patterns over time
   - Peak and off-peak utilization
   - Scaling frequency and effectiveness
   - Cost impact of scaling decisions

3. Optimize Scaling Policies

   Use cost_optimization recommendations for:
   - Scaling policy improvements
   - Instance type optimization
   - Capacity planning
   - Cost-aware scaling strategies

Example Auto Scaling Optimization:

// Step 1: Get Auto Scaling group recommendations
const asgRecommendations = usePower("aws-cost-optimization", "aws-billing-cost-management", "compute_optimizer", {
  "operation": "get_auto_scaling_group_recommendations"
})

// Step 2: Analyze hourly usage patterns to understand scaling needs
const hourlyUsage = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
  "operation": "getCostAndUsage",
  "start_date": "2024-11-25",
  "end_date": "2024-12-01",
  "granularity": "HOURLY",
  "group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"USAGE_TYPE\"}]",
  "filter": "{\"Dimensions\": {\"Key\": \"USAGE_TYPE_GROUP\", \"Values\": [\"EC2: Running Hours\"], \"MatchOptions\": [\"EQUALS\"]}}",
  "metrics": "[\"UsageQuantity\"]"
})

// Step 3: Compare costs during peak vs off-peak hours
const peakOffPeakAnalysis = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
  "query": `
    SELECT 
      CASE 
        WHEN EXTRACT(hour FROM timestamp) BETWEEN 9 AND 17 THEN 'Peak'
        ELSE 'Off-Peak'
      END as period,
      AVG(usage_quantity) as avg_instances,
      SUM(cost) as total_cost
    FROM usage_data 
    WHERE service = 'EC2'
    GROUP BY period
  `
})

// Step 4: Get specific ASG optimization recommendations
const asgOptimization = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_optimization", {
  "operation": "list_recommendations",
  "filters": "{\"resourceTypes\": [\"Ec2AutoScalingGroup\"], \"actionTypes\": [\"Rightsize\"]}"
})

Workflow 3: Serverless & Usage-Based Optimization

Goal: Maximize use of serverless and usage-based services to eliminate idle costs

Steps:

1. Analyze Lambda Function Performance

   Use compute_optimizer to optimize:
   - Lambda function memory allocation
   - Execution duration optimization
   - Cost per invocation analysis
   - Performance vs cost trade-offs

2. Identify Serverless Migration Opportunities

   Use cost_optimization to find:
   - Services suitable for serverless migration
   - Container workloads for Fargate
   - Database workloads for serverless options
   - Storage workloads for usage-based pricing

3. Analyze Usage-Based Service Costs

   Use getCostAndUsage to evaluate:
   - API Gateway usage patterns
   - Lambda invocation costs
   - DynamoDB consumption patterns
   - S3 request and storage patterns

Example Serverless Optimization:

// Step 1: Get Lambda function optimization recommendations
const lambdaOptimization = usePower("aws-cost-optimization", "aws-billing-cost-management", "compute_optimizer", {
  "operation": "get_lambda_function_recommendations"
})

// Step 2: Analyze Lambda usage patterns and costs
const lambdaCosts = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
  "operation": "getCostAndUsage",
  "start_date": "2024-11-01",
  "end_date": "2024-12-01",
  "granularity": "DAILY",
  "group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"USAGE_TYPE\"}]",
  "filter": "{\"Dimensions\": {\"Key\": \"SERVICE\", \"Values\": [\"AWS Lambda\"], \"MatchOptions\": [\"EQUALS\"]}}",
  "metrics": "[\"UnblendedCost\"]"
})

// Step 3: Compare serverless vs traditional architecture costs
const architectureComparison = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
  "query": `
    SELECT 
      'Traditional' as architecture,
      SUM(CASE WHEN service = 'EC2' THEN cost ELSE 0 END) as compute_cost,
      SUM(CASE WHEN service = 'RDS' THEN cost ELSE 0 END) as database_cost
    FROM costs
    WHERE month = '2024-11'
    UNION ALL
    SELECT 
      'Serverless' as architecture,
      SUM(CASE WHEN service = 'Lambda' THEN cost ELSE 0 END) as compute_cost,
      SUM(CASE WHEN service = 'DynamoDB' THEN cost ELSE 0 END) as database_cost
    FROM costs
    WHERE month = '2024-11'
  `
})

// Step 4: Identify migration opportunities
const migrationOpportunities = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_optimization", {
  "operation": "list_recommendations",
  "filters": "{\"actionTypes\": [\"MigrateToGraviton\"], \"implementationEfforts\": [\"Low\", \"Medium\"]}"
})

Workflow 4: Storage Consumption Optimization

Goal: Optimize storage costs through intelligent tiering and lifecycle management

Steps:

1. Analyze Storage Usage Patterns

   Use storage_lens to understand:
   - Storage class distribution
   - Access patterns and frequency
   - Lifecycle optimization opportunities
   - Cost optimization potential

2. Identify Storage Optimization Opportunities

   Use cost_optimization to find:
   - Unused EBS volumes
   - Storage class optimization
   - Lifecycle policy opportunities
   - Snapshot cleanup opportunities

3. Implement Storage Lifecycle Policies

   Use storage_lens analytics to:
   - Design optimal lifecycle policies
   - Monitor transition effectiveness
   - Track cost savings from optimization
   - Identify further optimization opportunities

Example Storage Optimization:

// Step 1: Analyze S3 storage patterns with Storage Lens
const storageAnalysis = usePower("aws-cost-optimization", "aws-billing-cost-management", "storage_lens", {
  "query": `
    SELECT
      storage_class,
      SUM(CAST(metric_value AS BIGINT)) as total_bytes,
      COUNT(DISTINCT bucket_name) as bucket_count
    FROM {table}
    WHERE metric_name = 'StorageBytes'
    GROUP BY storage_class
    ORDER BY total_bytes DESC
  `
})

// Step 2: Identify lifecycle optimization opportunities
const lifecycleOpportunities = usePower("aws-cost-optimization", "aws-billing-cost-management", "storage_lens", {
  "query": `
    SELECT
      bucket_name,
      SUM(CASE WHEN metric_name = 'NonCurrentVersionStorageBytes' THEN CAST(metric_value AS BIGINT) ELSE 0 END) as noncurrent_bytes,
      SUM(CASE WHEN metric_name = 'IncompleteMultipartUploadStorageBytes' THEN CAST(metric_value AS BIGINT) ELSE 0 END) as incomplete_bytes
    FROM {table}
    WHERE metric_name IN ('NonCurrentVersionStorageBytes', 'IncompleteMultipartUploadStorageBytes')
    GROUP BY bucket_name
    HAVING noncurrent_bytes > 0 OR incomplete_bytes > 0
    ORDER BY (noncurrent_bytes + incomplete_bytes) DESC
  `
})

// Step 3: Get EBS volume optimization recommendations
const ebsOptimization = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_optimization", {
  "operation": "list_recommendations",
  "filters": "{\"resourceTypes\": [\"EbsVolume\"], \"actionTypes\": [\"Delete\", \"Rightsize\"]}"
})

// Step 4: Analyze storage costs by class
const storageCostAnalysis = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
  "operation": "getCostAndUsage",
  "start_date": "2024-11-01",
  "end_date": "2024-12-01",
  "granularity": "MONTHLY",
  "group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"USAGE_TYPE\"}]",
  "filter": "{\"Dimensions\": {\"Key\": \"SERVICE\", \"Values\": [\"Amazon Simple Storage Service\"], \"MatchOptions\": [\"EQUALS\"]}}",
  "metrics": "[\"UnblendedCost\"]"
})

Consumption Model Best Practices

Dynamic Scaling Strategies

• **Predictive scaling**: Use historical patterns for proactive scaling
• **Multi-metric scaling**: Scale based on multiple performance indicators
• **Cost-aware scaling**: Consider cost implications in scaling decisions
• **Graceful scaling**: Implement smooth scaling transitions

Rightsizing Methodology

• **Continuous monitoring**: Regular performance and utilization monitoring
• **Gradual optimization**: Implement changes incrementally with monitoring
• **Performance validation**: Ensure performance requirements are met
• **Cost-benefit analysis**: Evaluate savings vs implementation effort

Usage-Based Service Adoption

• **Workload assessment**: Evaluate workloads for serverless suitability
• **Migration planning**: Plan phased migration to usage-based services
• **Cost modeling**: Model costs for different usage patterns
• **Performance testing**: Validate performance in usage-based architectures

Service-Specific Consumption Optimization

EC2 Optimization

• **Instance type selection**: Choose optimal instance types for workloads
• **Spot instance usage**: Use spot instances for fault-tolerant workloads
• **Reserved Instance planning**: Commit to consistent usage patterns
• **Auto Scaling implementation**: Implement effective auto scaling policies

Storage Optimization

• **S3 Intelligent Tiering**: Automatic optimization of storage classes
• **Lifecycle policies**: Automated transition to cheaper storage classes
• **EBS optimization**: Rightsize volumes and use appropriate types
• **Snapshot management**: Automated cleanup of old snapshots

Database Optimization

• **Aurora Serverless**: Use for variable database workloads
• **RDS rightsizing**: Optimize instance types and storage
• **DynamoDB on-demand**: Use for unpredictable workloads
• **Read replica optimization**: Optimize read replica usage

Serverless Optimization

• **Lambda memory optimization**: Optimize memory allocation for cost/performance
• **API Gateway optimization**: Optimize API usage patterns
• **Step Functions**: Use for workflow orchestration
• **EventBridge**: Use for event-driven architectures

Monitoring & Measurement

Key Metrics

• **Utilization rates**: CPU, memory, storage utilization
• **Scaling effectiveness**: Frequency and success of scaling events
• **Cost per unit**: Cost per transaction, user, or business metric
• **Idle resource percentage**: Percentage of resources with low utilization

Monitoring Tools

// Monitor utilization trends
const utilizationTrends = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
  "operation": "getCostAndUsage",
  "start_date": "2024-09-01",
  "end_date": "2024-12-01",
  "granularity": "MONTHLY",
  "group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"USAGE_TYPE_GROUP\"}]",
  "filter": "{\"Dimensions\": {\"Key\": \"USAGE_TYPE_GROUP\", \"Values\": [\"EC2: Running Hours\"], \"MatchOptions\": [\"EQUALS\"]}}",
  "metrics": "[\"UsageQuantity\"]"
})

Performance Validation

// Validate performance after optimization
const performanceValidation = usePower("aws-cost-optimization", "aws-billing-cost-management", "compute_optimizer", {
  "operation": "get_ec2_instance_recommendations",
  "filters": "{\"finding\": [\"Optimized\"]}"
})

Implementation Roadmap

Phase 1: Assessment (Weeks 1-2)

• Analyze current resource utilization
• Identify rightsizing opportunities
• Assess auto scaling effectiveness
• Evaluate serverless migration candidates

Phase 2: Quick Wins (Weeks 3-4)

• Implement obvious rightsizing opportunities
• Optimize Lambda function memory allocation
• Clean up unused resources
• Implement basic lifecycle policies

Phase 3: Advanced Optimization (Weeks 5-8)

• Implement advanced auto scaling policies
• Migrate suitable workloads to serverless
• Optimize storage classes and lifecycle policies
• Implement cost-aware scaling strategies

Phase 4: Continuous Optimization (Ongoing)

• Regular utilization monitoring and optimization
• Continuous rightsizing based on usage patterns
• Ongoing serverless migration opportunities
• Advanced consumption model adoption

Success Metrics

Cost Efficiency

• **Cost reduction**: Month-over-month cost reduction percentage
• **Utilization improvement**: Increase in average resource utilization
• **Idle resource reduction**: Decrease in idle or underutilized resources
• **Cost per unit improvement**: Improvement in cost per business metric

Operational Efficiency

• **Scaling responsiveness**: Time to scale up/down based on demand
• **Performance maintenance**: Maintain performance while reducing costs
• **Automation coverage**: Percentage of resources under automated management
• **Optimization velocity**: Speed of implementing optimization recommendations

Business Alignment

• **Demand responsiveness**: Ability to scale with business demand
• **Cost predictability**: Alignment of costs with business usage
• **Resource efficiency**: Optimal resource allocation for business needs
• **Innovation enablement**: Freed resources for new initiatives