Cloud Cost Optimization with FinOps: Automated Strategies for 2025

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# AWS CLI automation for right-sizing
aws ce get-dimension-values \
    --dimension KEY \
    --time-period Start=2025-04-01,End=2025-04-30 \
    --context COST_AND_USAGE

# Automated instance optimization script
#!/bin/bash
INSTANCES=$(aws ec2 describe-instances --query 'Reservations[].Instances[?State.Name==`running`].InstanceId' --output text)
for instance in $INSTANCES; do
    UTILIZATION=$(aws cloudwatch get-metric-statistics \
        --namespace AWS/EC2 \
        --metric-name CPUUtilization \
        --dimensions Name=InstanceId,Value=$instance \
        --start-time 2025-04-01T00:00:00Z \
        --end-time 2025-04-30T23:59:59Z \
        --period 3600 \
        --statistics Average)
    
    if [[ $(echo "$UTILIZATION" | jq '.Datapoints | length') -gt 0 ]]; then
        AVG_CPU=$(echo "$UTILIZATION" | jq '.Datapoints | map(.Average) | add / length')
        if (( $(echo "$AVG_CPU < 20" | bc -l) )); then
            echo "Instance $instance underutilized - Consider downsizing"
        fi
    fi
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# Automated scaling based on predictive analytics
import boto3
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
import datetime

class PredictiveScaler:
    def __init__(self):
        self.cloudwatch = boto3.client('cloudwatch')
        self.autoscaling = boto3.client('autoscaling')
        
    def predict_demand(self, metric_data):
        # Prepare time-series features
        df = pd.DataFrame(metric_data)
        df['hour'] = df['timestamp'].dt.hour
        df['day_of_week'] = df['timestamp'].dt.dayofweek
        
        # Train model on historical data
        features = ['hour', 'day_of_week', 'historical_load']
        model = RandomForestRegressor(n_estimators=100)
        model.fit(df[features], df['target_utilization'])
        
        # Predict next 24 hours
        future_load = self.generate_future_features()
        predictions = model.predict(future_load)
        
        return predictions
    
    def auto_schedule_scaling(self, asg_name, predictions):
        for i, predicted_load in enumerate(predictions):
            schedule_time = datetime.datetime.now() + datetime.timedelta(hours=i)
            
            if predicted_load > 80:
                desired_capacity = min(predicted_load // 20, 10)
            else:
                desired_capacity = max(predicted_load // 30, 2)
                
            self.schedule_scaling_action(asg_name, schedule_time, desired_capacity)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# Kubernetes automated workload placement
apiVersion: v1
kind: ConfigMap
metadata:
  name: cost-optimizer-config
data:
  providers.yaml: |
    providers:
      aws:
        regions: ["us-east-1", "us-west-2", "eu-west-1"]
        pricing_api: "https://pricing.us-east-1.amazonaws.com"
      azure:
        regions: ["eastus", "westus2", "westeurope"]
        pricing_api: "https://prices.azure.com"
      gcp:
        regions: ["us-central1", "us-west1", "europe-west1"]
        pricing_api: "https://cloudbilling.googleapis.com"
---
apiVersion: batch/v1
kind: CronJob
metadata:
  name: cost-arbitrage-scheduler
spec:
  schedule: "0 */6 * * *"  # Every 6 hours
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cost-optimizer
            image: cloudlogic/cost-optimizer:latest
            command:
            - /bin/sh
            - -c
            - |
              python3 /app/cost_arbitrage.py \
                --evaluate-placement \
                --threshold-savings 15 \
                --migrate-workloads

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Terraform automation for Lambda cost optimization
resource "aws_lambda_function" "cost_optimizer" {
  filename         = "cost_optimizer.zip"
  function_name    = "automated-cost-optimizer"
  role            = aws_iam_role.lambda_role.arn
  handler         = "index.handler"
  runtime         = "python3.9"
  timeout         = 300
  
  environment {
    variables = {
      OPTIMIZATION_THRESHOLD = "20"
      NOTIFICATION_SNS_TOPIC = aws_sns_topic.cost_alerts.arn
    }
  }
}

resource "aws_cloudwatch_event_rule" "cost_optimization_schedule" {
  name                = "cost-optimization-trigger"
  description         = "Trigger cost optimization every hour"
  schedule_expression = "rate(1 hour)"
}

resource "aws_cloudwatch_event_target" "lambda_target" {
  rule      = aws_cloudwatch_event_rule.cost_optimization_schedule.name
  target_id = "TriggerCostOptimizer"
  arn       = aws_lambda_function.cost_optimizer.arn
}