Oraclecloud Performance Tuning

Oracle Cloud Performance Tuning

Overview

Navigate OCI's opaque shape naming, block volume performance tiers, and shape-dependent network bandwidth. OCI shapes like VM.Standard.E5.Flex, VM.Standard3.Flex, and VM.Standard.A1.Flex look similar but have wildly different performance profiles. Block volume tiers (Balanced, Higher Performance, Ultra High Performance) have different IOPS and throughput limits that are easy to get wrong. This skill maps performance characteristics to shapes and storage tiers so you can make informed infrastructure decisions.

Purpose: Choose the right compute shape and storage tier for your workload by understanding OCI's performance characteristics, and monitor those resources programmatically.

Prerequisites

• OCI tenancy with an API signing key in ~/.oci/config
• Python 3.8+ with pip install oci
• Compartment OCID for querying available shapes and metrics
• Basic understanding of IOPS, throughput, and OCPU concepts

Instructions

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.