GCP Committed Use Discounts vs Sustained Use Discounts: Maximize Savings with Workload Analysis

As platform engineers, we're constantly balancing performance, reliability, and cost optimization. Google Cloud Platform's discount models—Committed Use Discounts (CUDs) and Sustained Use Discounts (SUDs)—represent one of the most underutilized levers for cost optimization, yet they're often misunderstood or poorly implemented.

After managing multi-million dollar cloud infrastructures and seeing organizations waste hundreds of thousands annually on suboptimal discount strategies, I'm convinced that workload analysis is the key to unlocking meaningful savings. Let me show you exactly how to approach this strategically.

Understanding the Discount Landscape

Before diving into analysis techniques, let's establish a clear understanding of what we're working with. Google's discount models serve different use cases, and choosing the wrong approach can actually increase your costs.

Sustained Use Discounts (SUDs): The Automatic Safety Net

SUDs are Google's automatic discount system that applies to Compute Engine and Google Kubernetes Engine resources. Here's the breakdown:

• 25% discount when you use resources for more than 25% of the month
• Up to 30% discount for continuous usage throughout the month
• Automatically applied with no commitment required
• Per-project basis with some cross-project aggregation

The discount curve is non-linear and kicks in progressively:

# SUD discount schedule
Hours 1-175 (0-25%):     0% discount
Hours 176-350 (25-50%):  20% of incremental usage
Hours 351-525 (50-75%):  40% of incremental usage  
Hours 526-730 (75-100%): 60% of incremental usage

Committed Use Discounts (CUDs): The Strategic Investment

CUDs require upfront commitment but offer deeper savings:

• 1-year commitment: Up to 57% discount
• 3-year commitment: Up to 70% discount
• Regional or global scope options
• Resource-specific (compute, memory, GPU, etc.)

The key insight most platform teams miss: CUDs stack with SUDs. Your committed usage gets SUD discounts applied on top of the CUD rate.

Building Your Workload Analysis Framework

Effective discount optimization starts with comprehensive workload analysis. Here's the framework I use to analyze usage patterns and make data-driven decisions.

Data Collection Strategy

First, establish your data pipeline. I use a combination of Cloud Billing export and custom monitoring to get granular usage insights:

-- BigQuery query for compute usage analysis
WITH compute_usage AS (
  SELECT 
    project.id as project_id,
    service.description as service,
    sku.description as sku_description,
    location.location as region,
    DATE(usage_start_time) as usage_date,
    DATETIME_TRUNC(usage_start_time, HOUR) as usage_hour,
    usage.amount as usage_amount,
    usage.unit as usage_unit,
    cost,
    credits
  FROM `your-project.cloud_billing.gcp_billing_export_v1_BILLING_ACCOUNT_ID`
  WHERE service.description = 'Compute Engine'
    AND DATE(usage_start_time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAYS)
    AND sku.description LIKE '%Instance%'
    AND sku.description NOT LIKE '%Preemptible%'
),

-- Calculate hourly usage patterns
hourly_patterns AS (
  SELECT
    project_id,
    sku_description,
    region,
    EXTRACT(HOUR FROM usage_hour) as hour_of_day,
    EXTRACT(DAYOFWEEK FROM usage_hour) as day_of_week,
    AVG(usage_amount) as avg_hourly_usage,
    MIN(usage_amount) as min_hourly_usage,
    MAX(usage_amount) as max_hourly_usage,
    STDDEV(usage_amount) as usage_variance
  FROM compute_usage
  GROUP BY 1,2,3,4,5
)

SELECT 
  project_id,
  sku_description,
  region,
  -- Calculate baseline usage (minimum sustained usage)
  MIN(min_hourly_usage) as baseline_usage,
  -- Calculate peak usage
  MAX(max_hourly_usage) as peak_usage,
  -- Calculate usage stability
  AVG(usage_variance) as avg_variance,
  -- Determine discount eligibility
  CASE 
    WHEN MIN(min_hourly_usage) > 0 THEN 'CUD_CANDIDATE'
    WHEN AVG(avg_hourly_usage) > 0 THEN 'SUD_OPTIMIZED'
    ELSE 'VARIABLE_WORKLOAD'
  END as discount_recommendation
FROM hourly_patterns
GROUP BY 1,2,3
ORDER BY baseline_usage DESC;

Workload Classification Engine

Not all workloads are created equal. I classify workloads into distinct categories that inform discount strategy:

#!/usr/bin/env python3
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class WorkloadClassifier:
    def __init__(self, usage_data):
        self.usage_data = usage_data
        
    def classify_workload(self, project_id, resource_type):
        """
        Classify workload based on usage patterns
        """
        df = self.usage_data[
            (self.usage_data['project_id'] == project_id) & 
            (self.usage_data['resource_type'] == resource_type)
        ]
        
        if df.empty:
            return "INSUFFICIENT_DATA"
        
        # Calculate key metrics
        usage_stability = self._calculate_stability(df)
        baseline_usage = self._calculate_baseline(df)
        growth_trend = self._calculate_growth_trend(df)
        
        return self._determine_classification(
            usage_stability, baseline_usage, growth_trend
        )
    
    def _calculate_stability(self, df):
        """Calculate coefficient of variation for usage stability"""
        daily_usage = df.groupby('date')['usage_amount'].sum()
        return daily_usage.std() / daily_usage.mean() if daily_usage.mean() > 0 else float('inf')
    
    def _calculate_baseline(self, df):
        """Calculate the minimum sustained usage level"""
        daily_usage = df.groupby('date')['usage_amount'].sum()
        return daily_usage.quantile(0.1)  # 10th percentile as baseline
    
    def _calculate_growth_trend(self, df):
        """Calculate monthly growth trend"""
        monthly_usage = df.groupby(df['date'].dt.to_period('M'))['usage_amount'].sum()
        if len(monthly_usage) < 2:
            return 0
        
        # Simple linear trend
        x = np.arange(len(monthly_usage))
        y = monthly_usage.values
        slope = np.polyfit(x, y, 1)[0]
        return slope / monthly_usage.mean() if monthly_usage.mean() > 0 else 0
    
    def _determine_classification(self, stability, baseline, growth):
        """
        Determine workload classification based on metrics
        """
        if stability < 0.2 and baseline > 10:  # Stable with significant baseline
            if growth > 0.1:  # Growing workload
                return "STABLE_GROWING"
            else:
                return "STABLE_STEADY"
        elif stability < 0.5 and baseline > 5:  # Moderately stable
            return "MODERATE_BASELINE"
        elif baseline > 0:  # Some baseline usage
            return "VARIABLE_WITH_BASELINE"
        else:
            return "HIGHLY_VARIABLE"

# Usage example
classifier = WorkloadClassifier(usage_data)
classification = classifier.classify_workload('prod-web-app', 'n1-standard-4')

Cost Impact Modeling

Once you understand your workload patterns, model the financial impact of different discount strategies:

class DiscountOptimizer:
    def __init__(self, hourly_rates):
        self.hourly_rates = hourly_rates
        
    def calculate_sud_savings(self, monthly_hours, hourly_usage):
        """
        Calculate SUD savings based on usage patterns
        """
        total_hours = sum(monthly_hours.values())
        total_cost_without_sud = total_hours * self.hourly_rates['base_rate']
        
        # Apply SUD discount curve
        sud_cost = 0
        cumulative_hours = 0
        
        for usage_level, hours in sorted(monthly_hours.items()):
            if cumulative_hours < 175:  # No discount zone
                discount_hours = min(hours, 175 - cumulative_hours)
                sud_cost += discount_hours * self.hourly_rates['base_rate']
            elif cumulative_hours < 350:  # 20% incremental discount
                discount_hours = min(hours, 350 - cumulative_hours)
                sud_cost += discount_hours * self.hourly_rates['base_rate'] * 0.8
            elif cumulative_hours < 525:  # 40% incremental discount  
                discount_hours = min(hours, 525 - cumulative_hours)
                sud_cost += discount_hours * self.hourly_rates['base_rate'] * 0.6
            else:  # 60% incremental discount
                sud_cost += hours * self.hourly_rates['base_rate'] * 0.4
                
            cumulative_hours += hours
            
        return {
            'original_cost': total_cost_without_sud,
            'sud_cost': sud_cost,
            'savings': total_cost_without_sud - sud_cost,
            'savings_percentage': (total_cost_without_sud - sud_cost) / total_cost_without_sud * 100
        }
    
    def calculate_cud_savings(self, committed_usage, actual_usage, commitment_term):
        """
        Calculate CUD savings for given commitment level
        """
        cud_rates = {
            '1_year': {'cpu': 0.43, 'memory': 0.43},  # 57% discount
            '3_year': {'cpu': 0.30, 'memory': 0.30}   # 70% discount
        }
        
        base_rate = self.hourly_rates['base_rate']
        cud_rate = base_rate * cud_rates[commitment_term]['cpu']
        
        # Cost for committed usage
        committed_cost = committed_usage * cud_rate * 730  # Monthly hours
        
        # Cost for usage above commitment (at SUD rates)
        excess_usage = max(0, actual_usage - committed_usage)
        excess_cost = excess_usage * base_rate * 730 * 0.7  # Assume average SUD discount
        
        # Cost without any discounts
        no_discount_cost = actual_usage * base_rate * 730
        
        total_cud_cost = committed_cost + excess_cost
        
        return {
            'no_discount_cost': no_discount_cost,
            'cud_cost': total_cud_cost,
            'savings': no_discount_cost - total_cud_cost,
            'savings_percentage': (no_discount_cost - total_cud_cost) / no_discount_cost * 100,
            'break_even_usage': committed_usage * 0.75  # Usage needed to break even
        }

# Example usage analysis
optimizer = DiscountOptimizer({'base_rate': 0.095})  # n1-standard-4 rate

# Analyze current workload
monthly_usage = {100: 200, 80: 300, 60: 230}  # usage_level: hours
sud_analysis = optimizer.calculate_sud_savings(monthly_usage, None)

# Compare with CUD option
cud_analysis = optimizer.calculate_cud_savings(
    committed_usage=50,  # 50 vCPUs committed
    actual_usage=75,     # 75 vCPUs average usage
    commitment_term='1_year'
)

Strategic Decision Framework

When to Choose SUDs

SUDs make sense for workloads with these characteristics:

1. Unpredictable scaling patterns - Development environments, seasonal applications
2. Short-term projects - Migrations, temporary capacity needs
3. Testing new applications - Before you understand long-term usage patterns
4. Variable baseline usage - Applications with significant traffic variations

Here's a practical assessment tool:

#!/bin/bash
# SUD Assessment Script
# Usage: ./assess_sud_suitability.sh PROJECT_ID RESOURCE_TYPE

PROJECT_ID=$1
RESOURCE_TYPE=$2

echo "Assessing SUD suitability for $PROJECT_ID / $RESOURCE_TYPE"

# Query usage variability over last 90 days
bq query --use_legacy_sql=false --format=csv \
"SELECT 
  DATE(usage_start_time) as date,
  SUM(usage.amount) as daily_usage
FROM \`$PROJECT_ID.cloud_billing.gcp_billing_export_v1_*\`
WHERE service.description = 'Compute Engine'
  AND sku.description LIKE '%$RESOURCE_TYPE%'
  AND DATE(usage_start_time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAYS)
GROUP BY 1
ORDER BY 1" > usage_data.csv

# Calculate variability metrics
python3 << EOF
import pandas as pd
import numpy as np

df = pd.read_csv('usage_data.csv')
df['daily_usage'] = pd.to_numeric(df['daily_usage'])

# Calculate key metrics
mean_usage = df['daily_usage'].mean()
std_usage = df['daily_usage'].std()
cv = std_usage / mean_usage if mean_usage > 0 else float('inf')
min_usage = df['daily_usage'].min()
max_usage = df['daily_usage'].max()

print(f"Usage Statistics:")
print(f"  Mean daily usage: {mean_usage:.2f}")
print(f"  Standard deviation: {std_usage:.2f}")
print(f"  Coefficient of variation: {cv:.2f}")
print(f"  Min/Max usage: {min_usage:.2f} / {max_usage:.2f}")

# SUD suitability assessment
if cv > 0.5:
    recommendation = "HIGHLY SUITABLE for SUDs - High variability"
elif cv > 0.3:
    recommendation = "SUITABLE for SUDs - Moderate variability"
elif min_usage > 0 and cv < 0.2:
    recommendation = "CONSIDER CUDs - Stable baseline usage detected"
else:
    recommendation = "MIXED - Further analysis needed"

print(f"\nRecommendation: {recommendation}")
EOF

rm usage_data.csv

When to Choose CUDs

CUDs become advantageous when you have:

1. Predictable baseline usage - Always-on production services
2. Stable long-term projects - Multi-year application lifecycles
3. Cost predictability requirements - Budget planning and forecasting
4. Significant sustained usage - High enough to justify commitment

The Hybrid Approach

In practice, the most effective strategy combines both discount types strategically:

class HybridDiscountStrategy:
    def __init__(self, workload_data):
        self.workload_data = workload_data
        
    def optimize_discount_mix(self, project_id):
        """
        Determine optimal mix of CUD and SUD strategy
        """
        workloads = self.workload_data[self.workload_data['project_id'] == project_id]
        
        strategy = {
            'cud_recommendations': [],
            'sud_workloads': [],
            'total_projected_savings': 0
        }
        
        for _, workload in workloads.iterrows():
            if self._is_cud_candidate(workload):
                cud_rec = self._calculate_optimal_commitment(workload)
                strategy['cud_recommendations'].append(cud_rec)
                strategy['total_projected_savings'] += cud_rec['annual_savings']
            else:
                strategy['sud_workloads'].append({
                    'resource_type': workload['resource_type'],
                    'reason': self._get_sud_reason(workload),
                    'projected_sud_savings': workload['estimated_sud_savings']
                })
                strategy['total_projected_savings'] += workload['estimated_sud_savings']
        
        return strategy
    
    def _is_cud_candidate(self, workload):
        """Determine if workload is suitable for CUD"""
        return (
            workload['usage_stability'] < 0.3 and
            workload['baseline_usage'] > 10 and
            workload['growth_trend'] > -0.1  # Not declining
        )
    
    def _calculate_optimal_commitment(self, workload):
        """Calculate optimal CUD commitment level"""
        baseline = workload['baseline_usage']
        
        # Conservative approach: commit to 80% of baseline
        commitment_level = baseline * 0.8
        
        # Calculate 1-year vs 3-year commitment ROI
        one_year_savings = self._calculate_cud_roi(commitment_level, '1_year', workload)
        three_year_savings = self._calculate_cud_roi(commitment_level, '3_year', workload)
        
        optimal_term = '3_year' if three_year_savings['roi'] > one_year_savings['roi'] else '1_year'
        
        return {
            'resource_type': workload['resource_type'],
            'commitment_level': commitment_level,
            'term': optimal_term,
            'annual_savings': three_year_savings['annual_savings'] if optimal_term == '3_year' else one_year_savings['annual_savings'],
            'roi': three_year_savings['roi'] if optimal_term == '3_year' else one_year_savings['roi']
        }

Implementation Best Practices

Infrastructure as Code Integration

Integrate discount optimization into your Terraform workflows:

# terraform/modules/compute/cud.tf
variable "commitment_level" {
  description = "CPU cores to commit (based on workload analysis)"
  type        = number
}

variable "commitment_term" {
  description = "Commitment term (1 or 3 years)"
  type        = string
  validation {
    condition     = contains(["1", "3"], var.commitment_term)
    error_message = "Commitment term must be 1 or 3 years."
  }
}

variable "region" {
  description = "Region for the commitment"
  type        = string
}

# Committed Use Discount for Compute Engine
resource "google_compute_region_commitment" "cpu_commitment" {
  name   = "${var.environment}-cpu-commitment"
  region = var.region
  
  # Calculate commitment based on workload analysis
  resources {
    type   = "VCPU"
    amount = var.commitment_level
  }
  
  # Memory commitment (typically 1:4 ratio with vCPU)
  resources {
    type   = "MEMORY"
    amount = var.commitment_level * 3.75  # GB per vCPU
  }
  
  commitment_period = "P${var.commitment_term}Y"
  
  lifecycle {
    prevent_destroy = true
  }
}

# Data source to track commitment utilization
data "google_compute_region_commitments" "current" {
  region = var.region
}

# Export commitment details for monitoring
output "commitment_details" {
  value = {
    commitment_id = google_compute_region_commitment.cpu_commitment.id
    vcpu_committed = var.commitment_level
    memory_committed = var.commitment_level * 3.75
    term = var.commitment_term
    region = var.region
  }
}

Automate the analysis and deployment process:

# .github/workflows/cost-optimization.yml
name: Cost Optimization Analysis

on:
  schedule:
    - cron: '0 8 * * MON'  # Weekly analysis
  workflow_dispatch:

jobs:
  analyze-discounts:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        pip install google-cloud-billing google-cloud-bigquery pandas numpy
    
    - name: Authenticate to GCP
      uses: google-github-actions/auth@v1
      with:
        credentials_json: '${{ secrets.GCP_CREDENTIALS }}'
    
    - name: Run workload analysis
      run: |
        python scripts/analyze_workloads.py --output-format terraform
    
    - name: Generate optimization recommendations
      run: |
        python scripts/generate_cud_recommendations.py \
          --project-id ${{ vars.GCP_PROJECT_ID }} \
          --output-dir terraform/environments/prod
    
    - name: Create optimization PR
      if: steps.analyze-discounts.outputs.recommendations-found == 'true'
      uses: peter-evans/create-pull-request@v5
      with:
        token: ${{ secrets.GITHUB_TOKEN }}
        commit-message: 'feat: optimize cloud costs based on workload analysis'
        title: 'Cost Optimization: CUD/SUD Recommendations'
        body: |
          ## Cost Optimization Recommendations
          
          This PR contains automated cost optimization recommendations based on workload analysis.
          
          ### Projected Annual Savings: ${{ steps.analyze-discounts.outputs.projected-savings }}
          
          ### Changes:
          - Updated CUD commitments based on usage patterns
          - Optimized resource allocation
          - Implemented discount strategy recommendations
          
          Please review the Terraform plan carefully before merging.
        branch: cost-optimization-${{ github.run_id }}

Monitoring and Alerting

Set up comprehensive monitoring to track discount utilization:

# monitoring/discount_monitoring.py
import logging
from google.cloud import monitoring_v3
from google.cloud import bigquery
from datetime import datetime, timedelta

class DiscountMonitor:
    def __init__(self, project_id):
        self.project_id = project_id
        self.monitoring_client = monitoring_v3.MetricServiceClient()
        self.bigquery_client = bigquery.Client()
        
    def check_commitment_utilization(self):
        """Monitor CUD utilization and alert on underutilization"""
        
        query = f"""
        WITH commitment_usage AS (
          SELECT 
            sku.description,
            location.region,
            SUM(usage.amount) as total_usage,
            SUM(CASE WHEN credits.amount IS NOT NULL THEN ABS(credits.amount) ELSE 0 END) as cud_credits
          FROM `{self.project_id}.cloud_billing.gcp_billing_export_v1_*`
          WHERE DATE(usage_start_time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAYS)
            AND service.description = 'Compute Engine'
            AND sku.description LIKE '%Commitment%'
          GROUP BY 1, 2
        )
        
        SELECT 
          sku_description,
          region,
          total_usage,
          cud_credits,
          CASE 
            WHEN total_usage > 0 THEN (cud_credits / total_usage) * 100 
            ELSE 0 
          END as utilization_percentage
        FROM commitment_usage
        WHERE (cud_credits / total_usage) * 100 < 80  -- Alert on <80% utilization
        """
        
        underutilized = self.bigquery_client.query(query).to_dataframe()
        
        if not underutilized.empty:
            self._send_utilization_alert(underutilized)
    
    def _send_utilization_alert(self, underutilized_commitments):
        """Send alert for underutilized commitments"""
        for _, commitment in underutilized_commitments.iterrows():
            self._create_alert_policy(
                f"CUD Underutilization: {commitment['sku_description']}",
                f"Commitment utilization at {commitment['utilization_percentage']:.1f}% "
                f"in region {commitment['region']}"
            )
    
    def track_savings_realization(self):
        """Track actual savings vs projected savings"""
        
        query = f"""
        SELECT 
          DATE_TRUNC(DATE(usage_start_time), MONTH) as month,
          SUM(cost) as total_cost,
          SUM(CASE WHEN credits.name LIKE '%Sustained%' THEN ABS(credits.amount) ELSE 0 END) as sud_savings,
          SUM(CASE WHEN credits.name LIKE '%Committed%' THEN ABS(credits.amount) ELSE 0 END) as cud_savings
        FROM `{self.project_id}.cloud_billing.gcp_billing_export_v1_*`
        WHERE DATE(usage_start_time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 6 MONTHS)
          AND service.description = 'Compute Engine'
        GROUP BY 1
        ORDER BY 1 DESC
        """
        
        savings_data = self.bigquery_client.query(query).to_dataframe()
        return self._analyze_savings_trends(savings_data)
    
    def _analyze_savings_trends(self, savings_data):
        """Analyze savings trends and identify optimization opportunities"""
        savings_data['total_savings'] = savings_data['sud_savings'] + savings_data['cud_savings']
        savings_data['savings_rate'] = (
            savings_data['total_savings'] / 
            (savings_data['total_cost'] + savings_data['total_savings']) * 100
        )
        
        latest_savings_rate = savings_data.iloc[0]['savings_rate']
        avg_savings_rate = savings_data['savings_rate'].mean()
        
        return {
            'current_savings_rate': latest_savings_rate,
            'average_savings_rate': avg_savings_rate,
            'trend': 'improving' if latest_savings_rate > avg_savings_rate else 'declining',
            'monthly_savings': savings_data.to_dict('records')
        }

# Usage in monitoring pipeline
monitor = DiscountMonitor('your-project-id')
utilization_check = monitor.check_commitment_utilization()
savings_analysis = monitor.track_savings_realization()

Common Pitfalls and How to Avoid Them

Over-Committing to CUDs

The biggest mistake I see is over-committing based on current usage without considering variability:

def calculate_safe_commitment_level(usage_history, confidence_level=0.9):
    """
    Calculate safe CUD commitment level based on historical usage
    """
    import numpy as np
    
    # Use conservative percentile to avoid over-commitment
    percentile = (1 - confidence_level) * 100
    safe_baseline = np.percentile(usage_history['daily_usage'], percentile)
    
    # Apply additional safety margin for workload volatility
    volatility = usage_history['daily_usage'].std() / usage_history['daily_usage'].mean()
    
    if volatility > 0.3:  # High volatility
        safety_margin = 0.7
    elif volatility > 0.2:  # Moderate volatility  
        safety_margin = 0.8
    else:  # Low volatility
        safety_margin = 0.9
    
    return safe_baseline * safety_margin

Ignoring Regional Considerations

CUD commitments are region-specific. Analyze your regional usage patterns:

-- Regional usage analysis for CUD planning
WITH regional_usage AS (
  SELECT 
    location.region,
    sku.description as resource_type,
    DATE(usage_start_time) as usage_date,
    SUM(usage.amount) as daily_usage,
    SUM(cost) as daily_cost
  FROM `project.cloud_billing.gcp_billing_export_v1_*`
  WHERE service.description = 'Compute Engine'
    AND DATE(usage_start_time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAYS)
    AND location.region IS NOT NULL
  GROUP BY 1,2,3
),

regional_stats AS (
  SELECT 
    region,
    resource_type,
    COUNT(*) as days_with_usage,
    MIN(daily_usage) as min_usage,
    AVG(daily_usage) as avg_usage,
    MAX(daily_usage) as max_usage,
    STDDEV(daily_usage) / AVG(daily_usage) as coefficient_variation
  FROM regional_usage
  GROUP BY 1,2
)

SELECT 
  region,
  resource_type,
  days_with_usage,
  min_usage as baseline_for_cud,
  avg_usage,
  coefficient_variation,
  CASE 
    WHEN coefficient_variation < 0.3 AND min_usage > 5 THEN 'STRONG_CUD_CANDIDATE'
    WHEN coefficient_variation < 0.5 AND min_usage > 2 THEN 'MODERATE_CUD_CANDIDATE'  
    ELSE 'SUD_PREFERRED'
  END as recommendation
FROM regional_stats
WHERE days_with_usage >= 60  -- At least 60 days of usage
ORDER BY min_usage DESC;

Not Monitoring Utilization

Set up automated monitoring for commitment utilization:

#!/bin/bash
# commitment_health_check.sh

PROJECT_ID="your-project"
THRESHOLD=75  # Alert if utilization < 75%

echo "Checking CUD utilization for project: $PROJECT_ID"

# Get current commitments
gcloud compute commitments list --project=$PROJECT_ID --format="value(name,region)" | while read commitment_name region; do
    
    echo "Checking commitment: $commitment_name in $region"
    
    # Query utilization from billing data
    utilization=$(bq query --use_legacy_sql=false --format=csv --max_rows=1 \
    "SELECT 
        ROUND(
            (SUM(CASE WHEN credits.name LIKE '%Committed%' THEN ABS(credits.amount) ELSE 0 END) / 
             SUM(cost + IFNULL(credits.amount, 0))) * 100, 
            2) as utilization_pct
    FROM \`$PROJECT_ID.cloud_billing.gcp_billing_export_v1_*\`
    WHERE DATE(usage_start_time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAYS)
      AND location.region = '$region'" | tail -n +2)
    
    if (( $(echo "$utilization < $THRESHOLD" | bc -l) )); then
        echo "⚠️  ALERT: Commitment $commitment_name utilization: $utilization% (below $THRESHOLD%)"
        # Send alert (Slack, email, etc.)
        curl -X POST -H 'Content-type: application/json' \
            --data "{\"text\":\"CUD Alert: $commitment_name utilization at $utilization%\"}" \
            $SLACK_WEBHOOK_URL
    else
        echo "✅ Commitment $commitment_name utilization: $utilization%"
    fi
done

Advanced Optimization Strategies

Dynamic Commitment Adjustment

For sophisticated workloads, implement dynamic commitment strategies:

class DynamicCommitmentOptimizer:
    def __init__(self, project_id):
        self.project_id = project_id
        self.historical_data = self._load_usage_history()
    
    def recommend_commitment_adjustments(self):
        """
        Analyze if current commitments should be modified
        """
        current_commitments = self._get_current_commitments()
        usage_trends = self._analyze_usage_trends()
        
        recommendations = []
        
        for commitment in current_commitments:
            region = commitment['region']
            committed_vcpu = commitment['vcpu_amount']
            
            # Get usage trend for this region
            trend = usage_trends.get(region, {})