🧩 Right-Sizing Resources for Azure & OCI

// Find underutilized VMs based on CPU metrics
let timeRange = 14d;
let cpuThreshold = 30;
resources
| where type == "microsoft.compute/virtualmachines"
| project name, resourceGroup, location, id, tags
| join kind=leftouter (
    metrics
    | where namespace == "Microsoft.Compute" and name == "Percentage CPU"
    | where timerange(ago(timeRange)..now())
    | summarize AvgCPU = avg(Average) by resource
) on $left.id == $right.resource
| where isnotnull(AvgCPU) and AvgCPU < cpuThreshold
| project name, resourceGroup, location, AvgCPU, tags
| order by AvgCPU asc

import oci
import datetime
from datetime import timedelta

# Initialize OCI clients
config = oci.config.from_file()
monitoring_client = oci.monitoring.MonitoringClient(config)
compute_client = oci.core.ComputeClient(config)
identity_client = oci.identity.IdentityClient(config)

# Set parameters
compartment_id = "ocid1.compartment.oc1..example"
days_to_analyze = 14
cpu_threshold = 30  # Average CPU utilization threshold

# Get current time and start time (14 days ago)
end_time = datetime.datetime.now()
start_time = end_time - timedelta(days=days_to_analyze)

# Get all instances in the compartment
instances = compute_client.list_instances(compartment_id).data

# Check CPU utilization for each instance
right_size_candidates = []

for instance in instances:
    # Skip instances that are not in RUNNING state
    if instance.lifecycle_state != "RUNNING":
        continue
        
    # Get CPU utilization metrics
    metric_data = monitoring_client.summarize_metrics_data(
        compartment_id=compartment_id,
        summarize_metrics_data_details=oci.monitoring.models.SummarizeMetricsDataDetails(
            namespace="oci_computeagent",
            query=f'CpuUtilization[{days_to_analyze}d].mean() {{ resourceId = "{instance.id}" }}',
            start_time=start_time,
            end_time=end_time,
            resolution="1d"
        )
    ).data
    
    # Calculate average CPU utilization
    if metric_data and len(metric_data) > 0 and len(metric_data[0].aggregated_datapoints) > 0:
        datapoints = metric_data[0].aggregated_datapoints
        avg_cpu = sum(point.value for point in datapoints) / len(datapoints)
        
        # Check if instance is a right-sizing candidate
        if avg_cpu < cpu_threshold:
            shape_details = None
            if hasattr(instance.shape_config, "ocpus"):
                shape_details = f"{instance.shape_config.ocpus} OCPUs, {instance.shape_config.memory_in_gbs} GB memory"
            
            right_size_candidates.append({
                "name": instance.display_name,
                "id": instance.id,
                "shape": instance.shape,
                "shape_details": shape_details,
                "avg_cpu": avg_cpu
            })

# Print right-sizing candidates
print(f"Found {len(right_size_candidates)} right-sizing candidates:")
for candidate in right_size_candidates:
    print(f"Instance: {candidate['name']}")
    print(f"  Shape: {candidate['shape']}")
    if candidate['shape_details']:
        print(f"  Details: {candidate['shape_details']}")
    print(f"  Avg CPU: {candidate['avg_cpu']:.2f}%")
    print(f"  Recommendation: Consider reducing OCPUs or changing to a smaller shape")
    print("")