Oracle Cloud Performance Tuning

Step 1: Understand Shape Naming

OCI shape names encode processor generation, type, and flexibility:

Key insight: Flex shapes let you choose OCPU and memory independently. Memory defaults to 1 GB/OCPU min, 64 GB/OCPU max (varies by shape). Network bandwidth scales linearly with OCPUs up to the shape maximum.

Step 2: Query Available Shapes

Discover what shapes are available in your tenancy and region:

import oci

config = oci.config.from_file("~/.oci/config")
compute = oci.core.ComputeClient(config)

shapes = compute.list_shapes(
    compartment_id="ocid1.compartment.oc1..example"
).data

for shape in shapes:
    print(
        f"{shape.shape}: "
        f"OCPUs={shape.ocpus or 'flex'}, "
        f"Memory={shape.memory_in_gbs or 'flex'} GB, "
        f"Network={shape.networking_bandwidth_in_gbps} Gbps"
    )

Step 3: Block Volume Performance Tiers

OCI block volumes have three performance tiers. IOPS and throughput scale with volume size:

Example: A 1 TB Balanced volume gets 25,000 IOPS and 480 MB/s throughput. The same 1 TB on Ultra High Performance gets up to 225,000 IOPS and 2.4 GB/s.

Step 4: Create a Performance-Tuned Block Volume

config = oci.config.from_file("~/.oci/config")
block_storage = oci.core.BlockstorageClient(config)

# Create a Higher Performance tier volume
volume = block_storage.create_volume(
    oci.core.models.CreateVolumeDetails(
        compartment_id="ocid1.compartment.oc1..example",
        availability_domain="Uocm:US-ASHBURN-AD-1",
        display_name="high-perf-data-vol",
        size_in_gbs=500,
        vpus_per_gb=20  # 10=Balanced, 20=Higher, 30-120=Ultra High
    )
).data

print(f"Volume created: {volume.id}")
print(f"Performance: {volume.vpus_per_gb} VPUs/GB")

The vpus_per_gb parameter controls the tier:

• 10 = Balanced (default)
• 20 = Higher Performance
• 30–120 = Ultra High Performance (scales IOPS linearly)

Step 5: Monitor Performance Metrics

Query actual performance data from running instances and volumes:

from datetime import datetime, timedelta

monitoring = oci.monitoring.MonitoringClient(config)

# Query disk IOPS for a specific instance
response = monitoring.summarize_metrics_data(
    compartment_id="ocid1.compartment.oc1..example",
    summarize_metrics_data_details=oci.monitoring.models.SummarizeMetricsDataDetails(
        namespace="oci_computeagent",
        query='DiskIopsRead[5m].mean() + DiskIopsWritten[5m].mean()',
        start_time=(datetime.utcnow() - timedelta(hours=1)).isoformat() + "Z",
        end_time=datetime.utcnow().isoformat() + "Z"
    )
)

for metric in response.data:
    for dp in metric.aggregated_datapoints:
        print(f"{dp.timestamp}: {dp.value:.0f} total IOPS")

Step 6: Network Bandwidth Validation

Verify you're getting expected network performance:

# Query network bytes for bandwidth validation
response = monitoring.summarize_metrics_data(
    compartment_id="ocid1.compartment.oc1..example",
    summarize_metrics_data_details=oci.monitoring.models.SummarizeMetricsDataDetails(
        namespace="oci_computeagent",
        query='NetworksBytesIn[5m].rate() + NetworksBytesOut[5m].rate()',
        start_time=(datetime.utcnow() - timedelta(hours=1)).isoformat() + "Z",
        end_time=datetime.utcnow().isoformat() + "Z"
    )
)

for metric in response.data:
    for dp in metric.aggregated_datapoints:
        gbps = (dp.value * 8) / 1_000_000_000
        print(f"{dp.timestamp}: {gbps:.2f} Gbps")

Output

Successful completion produces:

• A shape comparison showing processor, OCPU range, and network bandwidth
• Available shapes queried from your tenancy and region
• A block volume created with the appropriate performance tier
• Performance monitoring queries showing actual IOPS and throughput
• Network bandwidth validation against expected shape limits

Error Handling

Examples

Quick shape lookup with OCI CLI:

# List all flex shapes available in your compartment
oci compute shape list \
  --compartment-id ocid1.compartment.oc1..example \
  --query "data[?contains(shape, 'Flex')].{Shape:shape, OCPUs:ocpus, Memory:\"memory-in-gbs\"}" \
  --output table

# Check block volume performance tier
oci bv volume get \
  --volume-id ocid1.volume.oc1..example \
  --query "data.{Name:\"display-name\", SizeGB:\"size-in-gbs\", VPUsPerGB:\"vpus-per-gb\"}"

Right-size an instance based on CPU metrics:

import oci
from datetime import datetime, timedelta

config = oci.config.from_file("~/.oci/config")
monitoring = oci.monitoring.MonitoringClient(config)

# Get 7-day average CPU to check if over-provisioned
response = monitoring.summarize_metrics_data(
    compartment_id="ocid1.compartment.oc1..example",
    summarize_metrics_data_details=oci.monitoring.models.SummarizeMetricsDataDetails(
        namespace="oci_computeagent",
        query='CpuUtilization[1h].mean()',
        start_time=(datetime.utcnow() - timedelta(days=7)).isoformat() + "Z",
        end_time=datetime.utcnow().isoformat() + "Z"
    )
)

for metric in response.data:
    avg_cpu = sum(dp.value for dp in metric.aggregated_datapoints) / len(metric.aggregated_datapoints)
    if avg_cpu < 20:
        print(f"Instance {metric.dimensions.get('resourceId', 'unknown')}: "
              f"avg CPU {avg_cpu:.1f}% — consider downsizing")

Resources

• OCI Compute Shapes — full shape specifications
• OCI Block Volume Performance — IOPS/throughput by tier
• OCI Python SDK — SDK reference
• OCI Pricing — cost per OCPU, storage, and network
• OCI API Reference — REST API specs

Next Steps

After optimizing shapes and storage, proceed to oraclecloud-cost-tuning to track spend and set budget alerts, or see oraclecloud-observability to set up ongoing performance monitoring with alarms.