undefined

echo "=== AWS Cost Analysis ==="

# Get daily cost trend
echo "Daily costs for last 7 days:"
aws ce get-cost-and-usage \
  --time-period Start=$(date -d '7 days ago' +%Y-%m-%d),End=$(date +%Y-%m-%d) \
  --granularity DAILY \
  --metrics "BlendedCost" \
  --group-by Type=DIMENSION,Key=SERVICE \
  --query 'ResultsByTime[*].[TimePeriod.Start,Total.BlendedCost.Amount]' \
  --output table

# Find unattached resources
echo -e "\n=== Unattached EBS Volumes ==="
aws ec2 describe-volumes \
  --filters Name=status,Values=available \
  --query 'Volumes[*].[VolumeId,Size,CreateTime]' \
  --output table

echo -e "\n=== Unattached Elastic IPs ==="
aws ec2 describe-addresses \
  --filters Name=association-id,Values=none \
  --query 'Addresses[*].[PublicIp,AllocationId]' \
  --output table

echo -e "\n=== Unused RDS Instances ==="
aws rds describe-db-instances \
  --query 'DBInstances[?DBInstanceStatus==`available`].[DBInstanceIdentifier,DBInstanceClass,Engine,AllocatedStorage]' \
  --output table

# Estimate savings with Reserved Instances
echo -e "\n=== Reserved Instance Savings Potential ==="
aws ce get-reservation-purchase-recommendation \
  --service "EC2" \
  --lookback-period THIRTY_DAYS \
  --query 'Recommendations[0].[RecommendationSummary.TotalEstimatedMonthlySavingsAmount,RecommendationSummary.TotalEstimatedMonthlySavingsPercentage]' \
  --output table

echo "Starting resource optimization..."

# Remove unattached volumes
echo "Removing unattached volumes..."
aws ec2 describe-volumes \
  --filters Name=status,Values=available \
  --query 'Volumes[*].VolumeId' \
  --output text | \
while read volume_id; do
  echo "Deleting volume: $volume_id"
  aws ec2 delete-volume --volume-id "$volume_id" 2>/dev/null || true
done

# Release unused Elastic IPs
echo "Releasing unused Elastic IPs..."
aws ec2 describe-addresses \
  --filters Name=association-id,Values=none \
  --query 'Addresses[*].AllocationId' \
  --output text | \
while read alloc_id; do
  echo "Releasing EIP: $alloc_id"
  aws ec2 release-address --allocation-id "$alloc_id" 2>/dev/null || true
done

# Modify RDS to smaller instances
echo "Analyzing RDS for downsizing..."
# Implement logic to check CloudWatch metrics and downsize if needed

echo "Optimization complete"

spot_options {
  max_price                      = "0.05"  # Set max price
  spot_instance_type             = "persistent"
  interrupt_behavior             = "terminate"
  valid_until                    = "2025-12-31T23:59:59Z"
}

overrides {
  instance_type       = "t3.medium"
  weighted_capacity   = "1"
  priority            = 1  # Reserved
}

overrides {
  instance_type       = "t3.large"
  weighted_capacity   = "2"
  priority            = 2  # Reserved
}

overrides {
  instance_type       = "t3a.medium"
  weighted_capacity   = "1"
  priority            = 3  # Spot
}

overrides {
  instance_type       = "t3a.large"
  weighted_capacity   = "2"
  priority            = 4  # Spot
}

undefined

undefined

  # Prefer nodes with lower cost
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 100
          preference:
            matchExpressions:
              - key: karpenter.sh/capacity-type
                operator: In
                values: ["spot"]

  containers:
    - name: app
      image: myapp:latest
      resources:
        requests:
          cpu: 100m
          memory: 128Mi
        limits:
          cpu: 500m
          memory: 512Mi

undefined

undefined

def get_daily_costs(self, days=30):
    """Get daily costs for past N days"""
    end_date = datetime.now().date()
    start_date = end_date - timedelta(days=days)

    response = self.ce_client.get_cost_and_usage(
        TimePeriod={
            'Start': str(start_date),
            'End': str(end_date)
        },
        Granularity='DAILY',
        Metrics=['BlendedCost'],
        GroupBy=[
            {'Type': 'DIMENSION', 'Key': 'SERVICE'}
        ]
    )

    return response

def find_underutilized_instances(self):
    """Find EC2 instances with low CPU usage"""
    cloudwatch = boto3.client('cloudwatch')
    instances = []

    ec2_instances = self.ec2_client.describe_instances()
    for reservation in ec2_instances['Reservations']:
        for instance in reservation['Instances']:
            instance_id = instance['InstanceId']

            # Check CPU utilization
            response = cloudwatch.get_metric_statistics(
                Namespace='AWS/EC2',
                MetricName='CPUUtilization',
                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                StartTime=datetime.now() - timedelta(days=7),
                EndTime=datetime.now(),
                Period=3600,
                Statistics=['Average']
            )

            if response['Datapoints']:
                avg_cpu = sum(d['Average'] for d in response['Datapoints']) / len(response['Datapoints'])
                if avg_cpu < 10:  # Less than 10% average
                    instances.append({
                        'InstanceId': instance_id,
                        'Type': instance['InstanceType'],
                        'AverageCPU': avg_cpu,
                        'Recommendation': 'Downsize or terminate'
                    })

    return instances

def estimate_reserved_instance_savings(self):
    """Estimate potential savings from reserved instances"""
    response = self.ce_client.get_reservation_purchase_recommendation(
        Service='EC2',
        LookbackPeriod='THIRTY_DAYS',
        PageSize=100
    )

    total_savings = 0
    for recommendation in response.get('Recommendations', []):
        summary = recommendation['RecommendationSummary']
        savings = float(summary['EstimatedMonthlyMonthlySavingsAmount'])
        total_savings += savings

    return total_savings

def generate_report(self):
    """Generate comprehensive cost optimization report"""
    print("=== Cost Optimization Report ===\n")

    # Daily costs
    print("Daily Costs:")
    costs = self.get_daily_costs(7)
    for result in costs['ResultsByTime']:
        date = result['TimePeriod']['Start']
        total = result['Total']['BlendedCost']['Amount']
        print(f"  {date}: ${total}")

    # Underutilized instances
    print("\nUnderutilized Instances:")
    underutilized = self.find_underutilized_instances()
    for instance in underutilized:
        print(f"  {instance['InstanceId']}: {instance['AverageCPU']:.1f}% CPU - {instance['Recommendation']}")

    # Reserved instance savings
    print("\nReserved Instance Savings Potential:")
    savings = self.estimate_reserved_instance_savings()
    print(f"  Estimated Monthly Savings: ${savings:.2f}")

undefined