Oracle Cloud Infrastructure Python SDK

https://docs.oracle.com/en-us/iaas/tools/python/2.155.0/
Admin
The Oracle Cloud Infrastructure Python SDK provides a set of libraries for developers to interact...
Tokens:11,039
Snippets:28
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Initialize OCI Client and Get User Info with Python SDK

Source: https://docs.oracle.com/en-us/iaas/tools/python/2.155.0/index

Demonstrates how to initialize the Oracle Cloud Infrastructure (OCI) Python SDK, load configuration from a file, create an IdentityClient, and retrieve user details. Requires the OCI Python SDK and a valid configuration file.

```python
import oci
config = oci.config.from_file("~/.oci/config", "integ-beta-profile")
identity = oci.identity.IdentityClient(config)
user = identity.get_user(config["user"]).data
print(user)
```

--------------------------------

### Manage Oracle Cloud Infrastructure Instances using Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet demonstrates launching an Oracle Cloud Infrastructure instance, waiting for it to reach the RUNNING state, stopping it, and then starting it again. It utilizes the oci.core.models and wait_until utility for state management. It handles potential ServiceError and MaximumWaitTimeExceeded exceptions.

```python
import oci

# Assuming compute, compartment_id, availability_domain, and wait_until are defined elsewhere

instance_details = oci.core.models.LaunchInstanceDetails(
    availability_domain=availability_domain,
    compartment_id=compartment_id,
    display_name="app-server",
    shape="VM.Standard.E4.Flex",
    shape_config=oci.core.models.LaunchInstanceShapeConfigDetails(
        ocpus=1,
        memory_in_gbs=8
    ),
    source_details=oci.core.models.InstanceSourceViaImageDetails(
        image_id="ocid1.image.oc1.phx...",
        source_type="image"
    ),
    create_vnic_details=oci.core.models.CreateVnicDetails(
        subnet_id="ocid1.subnet.oc1.phx..."
    )
)

try:
    launch_response = compute.launch_instance(instance_details)
    instance_id = launch_response.data.id
    print(f"Instance launching: {instance_id}")

    # Wait for instance to be running (default waiter)
    get_instance_response = wait_until(
        compute,
        compute.get_instance(instance_id),
        'lifecycle_state',
        'RUNNING',
        max_wait_seconds=300,
        max_interval_seconds=30
    )
    instance = get_instance_response.data
    print(f"Instance is RUNNING: {instance.display_name}")

    # Stop instance and wait
    print("Stopping instance...")
    compute.instance_action(instance_id, "STOP")

    wait_until(
        compute,
        compute.get_instance(instance_id),
        'lifecycle_state',
        'STOPPED',
        max_wait_seconds=300
    )
    print("Instance stopped")

    # Create volume and wait for multiple possible states
    volume_details = oci.core.models.CreateVolumeDetails(
        compartment_id=compartment_id,
        availability_domain=availability_domain,
        display_name="data-volume",
        size_in_gbs=100
    )

    volume_response = blockstorage.create_volume(volume_details)
    volume_id = volume_response.data.id
    print(f"Volume creating: {volume_id}")

    # Wait for volume to be available or provisioning to complete
    volume = wait_until(
        blockstorage,
        blockstorage.get_volume(volume_id),
        'lifecycle_state',
        'AVAILABLE',
        succeed_on_not_found=False,
        max_wait_seconds=300
    ).data
    print(f"Volume available: {volume.display_name}")

    # Custom evaluation function for complex conditions
    def is_instance_ready(response):
        """Custom check: instance running AND has private IP"""
        instance = response.data
        if instance.lifecycle_state != 'RUNNING':
            return False

        # Check if VNIC is attached and has IP
        vnic_attachments = compute.list_vnic_attachments(
            compartment_id=compartment_id,
            instance_id=instance.id
        ).data

        return len(vnic_attachments) > 0 and vnic_attachments[0].lifecycle_state == 'ATTACHED'

    # Start instance again
    compute.instance_action(instance_id, "START")

    wait_until(
        compute,
        compute.get_instance(instance_id),
        evaluate_response=is_instance_ready,
        max_wait_seconds=300
    )
    print("Instance ready with network connectivity")

except oci.exceptions.ServiceError as e:
    print(f"Operation failed: {e.message}")
except oci.exceptions.MaximumWaitTimeExceeded:
    print("Operation timed out waiting for desired state")
```

--------------------------------

### Install OCI Python SDK using Pip

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Installs or upgrades the Oracle Cloud Infrastructure Python SDK using pip. Requires Python 3.6 or higher. Supports installing specific versions and verifying the installation.

```bash
# Install the latest version of the OCI Python SDK
pip install oci

# Install a specific version
pip install oci==2.161.0

# Upgrade to the latest version
pip install --upgrade oci

# Verify installation
python -c "import oci; print(oci.__version__)"
```

--------------------------------

### Create Virtual Cloud Network (VCN) Infrastructure using Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This Python example demonstrates creating a complete Virtual Cloud Network (VCN) infrastructure using the OCI Python SDK. It includes creating a VCN, an Internet Gateway, a Security List with ingress and egress rules, and a public subnet. It utilizes the `VirtualNetworkClient` and `oci.wait_until` for resource availability.

```python
import oci

config = oci.config.from_file()
virtual_network = oci.core.VirtualNetworkClient(config)
compartment_id = "ocid1.compartment.oc1..."

# Create VCN
vcn_details = oci.core.models.CreateVcnDetails(
    cidr_block="10.0.0.0/16",
    compartment_id=compartment_id,
    display_name="production-vcn",
    dns_label="prodvcn"
)

try:
    vcn_response = virtual_network.create_vcn(vcn_details)
    vcn = vcn_response.data
    print(f"VCN Created: {vcn.id}")
    print(f"CIDR Block: {vcn.cidr_block}")

    # Wait for VCN to be available
    vcn = oci.wait_until(
        virtual_network,
        virtual_network.get_vcn(vcn.id),
        'lifecycle_state',
        'AVAILABLE'
    ).data

    # Create Internet Gateway
    ig_details = oci.core.models.CreateInternetGatewayDetails(
        compartment_id=compartment_id,
        vcn_id=vcn.id,
        is_enabled=True,
        display_name="production-ig"
    )
    ig_response = virtual_network.create_internet_gateway(ig_details)
    internet_gateway = ig_response.data
    print(f"Internet Gateway Created: {internet_gateway.id}")

    # Create Security List
    security_list_details = oci.core.models.CreateSecurityListDetails(
        compartment_id=compartment_id,
        vcn_id=vcn.id,
        display_name="web-security-list",
        egress_security_rules=[
            oci.core.models.EgressSecurityRule(
                destination="0.0.0.0/0",
                protocol="all",
                is_stateless=False
            )
        ],
        ingress_security_rules=[
            oci.core.models.IngressSecurityRule(
                source="0.0.0.0/0",
                protocol="6",  # TCP
                is_stateless=False,
                tcp_options=oci.core.models.TcpOptions(
                    destination_port_range=oci.core.models.PortRange(
                        min=443,
                        max=443
                    )
                )
            )
        ]
    )
    sl_response = virtual_network.create_security_list(security_list_details)
    security_list = sl_response.data
    print(f"Security List Created: {security_list.id}")

    # Create Subnet
    subnet_details = oci.core.models.CreateSubnetDetails(
        compartment_id=compartment_id,
        vcn_id=vcn.id,
        cidr_block="10.0.1.0/24",
        display_name="public-subnet",
        dns_label="pubsub",
        security_list_ids=[security_list.id]
    )
    subnet_response = virtual_network.create_subnet(subnet_details)
    subnet = subnet_response.data
    print(f"Subnet Created: {subnet.id}")
    print(f"Subnet CIDR: {subnet.cidr_block}")

except oci.exceptions.ServiceError as e:
    print(f"Network creation error: {e.message}")
    print(f"Status: {e.status}")
```

--------------------------------

### Get OCI Autonomous Database Connection Details with Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet shows how to retrieve connection strings and wallet credentials for an OCI Autonomous Database using the Python SDK. It utilizes the DatabaseClient to fetch Autonomous Database details, including database name, state, and various connection string profiles. It includes error handling for service errors.

```python
import oci

config = oci.config.from_file()
database_client = oci.database.DatabaseClient(config)

autonomous_database_id = "ocid1.autonomousdatabase.oc1.phx..."

# Get Autonomous Database details
try:
    adb_response = database_client.get_autonomous_database(
        autonomous_database_id=autonomous_database_id
    )
    adb = adb_response.data

    print(f"Database Name: {adb.db_name}")
    print(f"Display Name: {adb.display_name}")
    print(f"State: {adb.lifecycle_state}")
    print(f"CPU Core Count: {adb.cpu_core_count}")
    print(f"Data Storage (TB): {adb.data_storage_size_in_tbs}")
    print(f"Service Console URL: {adb.service_console_url}")

    # Get connection strings
    print("\nConnection Strings:")
    for profile, conn_string in adb.connection_strings.all_connection_strings.items():
        print(f"  {profile}: {conn_string}")

except oci.exceptions.ServiceError as e:
    print(f"Error retrieving database: {e.message}")
```

--------------------------------

### Launch OCI Instance with Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet demonstrates how to define instance configuration and launch a virtual machine instance in OCI using the Python SDK. It includes details for compartment, availability domain, image, subnet, shape, and metadata. It also shows how to wait for the instance to reach the 'RUNNING' state and includes error handling for service errors.

```python
import oci

# Define instance configuration
compartment_id = "ocid1.compartment.oc1..."
availability_domain = "AD-1"
image_id = "ocid1.image.oc1.phx..."
subnet_id = "ocid1.subnet.oc1.phx..."

instance_details = oci.core.models.LaunchInstanceDetails(
    availability_domain=availability_domain,
    compartment_id=compartment_id,
    display_name="web-server-01",
    shape="VM.Standard.E4.Flex",
    shape_config=oci.core.models.LaunchInstanceShapeConfigDetails(
        ocpus=2,
        memory_in_gbs=16
    ),
    source_details=oci.core.models.InstanceSourceViaImageDetails(
        image_id=image_id,
        source_type="image"
    ),
    create_vnic_details=oci.core.models.CreateVnicDetails(
        subnet_id=subnet_id,
        assign_public_ip=True
    ),
    metadata={
        "ssh_authorized_keys": "ssh-rsa AAAAB3NzaC1yc2E...",
        "user_data": "IyEvYmluL2Jhc2gKZWNobyAiSGVsbG8gV29ybGQi"
    }
)

# Launch the instance
try:
    # Assuming compute_client is already initialized: compute_client = oci.core.ComputeClient(config)
    launch_response = compute_client.launch_instance(instance_details)
    instance = launch_response.data
    print(f"Instance launched: {instance.id}")
    print(f"State: {instance.lifecycle_state}")

    # Wait for instance to be running
    get_instance_response = oci.wait_until(
        compute_client,
        compute_client.get_instance(instance.id),
        'lifecycle_state',
        'RUNNING',
        max_wait_seconds=300
    )
    print(f"Instance is now running: {get_instance_response.data.lifecycle_state}")

except oci.exceptions.ServiceError as e:
    print(f"Error launching instance: {e.message}")
```

--------------------------------

### Manage OCI Compute Instances

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Initializes OCI Compute and Virtual Network clients for managing compute instances. This snippet sets up the clients but does not include the instance creation logic itself.

```python
import oci

config = oci.config.from_file()
compute_client = oci.core.ComputeClient(config)
virtual_network_client = oci.core.VirtualNetworkClient(config)
```

--------------------------------

### Create, Attach, and Backup Block Volume with OCI Python SDK

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This code snippet demonstrates how to create a block volume, attach it to an instance, and create a backup of the volume using the OCI Python SDK. It includes waiting for resources to become available and basic error handling for OCI service errors. Dependencies include the OCI SDK.

```python
import oci

# Assuming compartment_id, availability_domain, instance_id are defined
# Assuming blockstorage and compute clients are initialized

volume_details = oci.core.models.CreateVolumeDetails(
    compartment_id=compartment_id,
    availability_domain=availability_domain,
    display_name="database-storage",
    size_in_gbs=256,
    vpus_per_gb=20,  # Performance level
    is_auto_tune_enabled=True
)

try:
    volume_response = blockstorage.create_volume(volume_details)
    volume = volume_response.data
    print(f"Volume Created: {volume.id}")
    print(f"Size: {volume.size_in_gbs} GB")

    # Wait for volume to be available
    volume = oci.wait_until(
        blockstorage,
        blockstorage.get_volume(volume.id),
        'lifecycle_state',
        'AVAILABLE',
        max_wait_seconds=300
    ).data
    print(f"Volume State: {volume.lifecycle_state}")

    # Attach volume to instance
    attach_details = oci.core.models.AttachParavirtualizedVolumeDetails(
        display_name="database-storage-attachment",
        instance_id=instance_id,
        volume_id=volume.id,
        is_read_only=False,
        is_shareable=False
    )

    attach_response = compute.attach_volume(attach_details)
    attachment = attach_response.data
    print(f"Volume Attachment Created: {attachment.id}")

    # Wait for attachment to complete
    attachment = oci.wait_until(
        compute,
        compute.get_volume_attachment(attachment.id),
        'lifecycle_state',
        'ATTACHED',
        max_wait_seconds=300
    ).data
    print(f"Volume attached successfully")
    print(f"Device: {attachment.device if hasattr(attachment, 'device') else 'N/A'}")

    # Create volume backup
    backup_details = oci.core.models.CreateVolumeBackupDetails(
        volume_id=volume.id,
        display_name="database-storage-backup-daily",
        type="FULL"
    )
    backup_response = blockstorage.create_volume_backup(backup_details)
    backup = backup_response.data
    print(f"Backup Created: {backup.id}")

except oci.exceptions.ServiceError as e:
    print(f"Error: {e.message}")
    print(f"Status Code: {e.status}")
```

--------------------------------

### Create Block Volume and Attach to Instance

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This API demonstrates the process of creating a block volume, waiting for it to become available, attaching it to a specified instance, and waiting for the attachment to complete.

```APIDOC
## POST /core/BlockStorage/actions/createVolume

### Description
Creates a new block volume with specified details, such as compartment, availability domain, size, and performance.

### Method
POST

### Endpoint
/core/BlockStorage/actions/createVolume

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **compartment_id** (string) - Required - The OCID of the compartment to create the volume in.
- **availability_domain** (string) - Required - The availability domain for the volume.
- **display_name** (string) - Optional - A user-friendly name for the volume.
- **size_in_gbs** (integer) - Required - The size of the volume in GBs.
- **vpus_per_gb** (integer) - Optional - The number of Volume Performance Units per GB of size. 
- **is_auto_tune_enabled** (boolean) - Optional - Whether to enable auto-tune for the volume.

### Request Example
```json
{
  "compartment_id": "ocid1.compartment.oc1...",
  "availability_domain": "phx-ad-1",
  "display_name": "database-storage",
  "size_in_gbs": 256,
  "vpus_per_gb": 20,
  "is_auto_tune_enabled": true
}
```

### Response
#### Success Response (200)
- **id** (string) - The OCID of the created volume.
- **size_in_gbs** (integer) - The size of the volume in GBs.
- **lifecycle_state** (string) - The current state of the volume (e.g., AVAILABLE, PROVISIONING).

#### Response Example
```json
{
  "id": "ocid1.volume.oc1.phx...",
  "size_in_gbs": 256,
  "lifecycle_state": "AVAILABLE"
}
```

---

## POST /core/Compute/actions/attachVolume

### Description
Attaches a block volume to a specified compute instance.

### Method
POST

### Endpoint
/core/Compute/actions/attachVolume

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **display_name** (string) - Optional - A user-friendly name for the volume attachment.
- **instance_id** (string) - Required - The OCID of the instance to attach the volume to.
- **volume_id** (string) - Required - The OCID of the volume to attach.
- **is_read_only** (boolean) - Optional - Whether the volume should be attached in read-only mode.
- **is_shareable** (boolean) - Optional - Whether the volume should be shareable.

### Request Example
```json
{
  "display_name": "database-storage-attachment",
  "instance_id": "ocid1.instance.oc1...",
  "volume_id": "ocid1.volume.oc1...",
  "is_read_only": false,
  "is_shareable": false
}
```

### Response
#### Success Response (200)
- **id** (string) - The OCID of the volume attachment.
- **device** (string) - The device name assigned to the volume on the instance.
- **lifecycle_state** (string) - The current state of the attachment (e.g., ATTACHED, DETACHING).

#### Response Example
```json
{
  "id": "ocid1.volumeattachment.oc1...",
  "device": "/dev/oracleoci/orion/disk0",
  "lifecycle_state": "ATTACHED"
}
```

---

## POST /core/BlockStorage/actions/createVolumeBackup

### Description
Creates a backup of a specified block volume.

### Method
POST

### Endpoint
/core/BlockStorage/actions/createVolumeBackup

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **volume_id** (string) - Required - The OCID of the volume to back up.
- **display_name** (string) - Optional - A user-friendly name for the backup.
- **type** (string) - Required - The type of backup (e.g., FULL, INCREMENTAL).

### Request Example
```json
{
  "volume_id": "ocid1.volume.oc1...",
  "display_name": "database-storage-backup-daily",
  "type": "FULL"
}
```

### Response
#### Success Response (200)
- **id** (string) - The OCID of the created backup.

#### Response Example
```json
{
  "id": "ocid1.volumebackup.oc1..."
}
```
```

--------------------------------

### Create and Manage Tags, Tag Compute Instances, Search Resources (Python)

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet demonstrates how to create tag namespaces and keys, apply defined and freeform tags to a compute instance, and search for resources using these tags with the OCI SDK for Python. It includes error handling for service exceptions.

```python
import oci

# Assuming config and compartment_id are already defined
# config = oci.config.from_file()
# compartment_id = "your_compartment_id"

tag_NAMESPACE_NAME = "Operations"
TAG_KEY_NAME = "Environment"
TAG_VALUE = "Production"
INSTANCE_ID = "ocid1.instance.oc1.phx..."

# Initialize clients
identity = oci.identity.IdentityClient(config)
compute = oci.core.ComputeClient(config)
search_client = oci.resource_search.ResourceSearchClient(config)

# 1. Create tag namespace
tag_NAMESPACE_NAME = "Operations"
tag_namespace_details = oci.identity.models.CreateTagNamespaceDetails(
    compartment_id=compartment_id,
    name=TAG_NAMESPACE_NAME,
    description="Operations and management tags"
)

try:
    namespace_response = identity.create_tag_namespace(tag_namespace_details)
    tag_namespace = namespace_response.data
    print(f"Tag Namespace Created: {tag_namespace.id}")

    # Wait for namespace to be active
    tag_namespace = oci.wait_until(
        identity,
        identity.get_tag_namespace(tag_namespace.id),
        'lifecycle_state',
        'ACTIVE'
    ).data

    # 2. Create tag key
    tag_key_details = oci.identity.models.CreateTagDetails(
        tag_namespace_id=tag_namespace.id,
        name=TAG_KEY_NAME,
        description="Deployment environment identifier"
    )
    tag_key_response = identity.create_tag(
        tag_namespace_id=tag_namespace.id,
        create_tag_details=tag_key_details
    )
    tag_key = tag_key_response.data
    print(f"Tag Key Created: {tag_key.name}")

    # 3. Tag a compute instance
    update_instance_details = oci.core.models.UpdateInstanceDetails(
        defined_tags={
            TAG_NAMESPACE_NAME: {
                TAG_KEY_NAME: TAG_VALUE
            }
        },
        freeform_tags={
            "Project": "WebApp",
            "CostCenter": "Engineering"
        }
    )

    instance_response = compute.update_instance(
        instance_id=INSTANCE_ID,
        update_instance_details=update_instance_details
    )
    instance = instance_response.data
    print(f"Instance tagged: {instance.id}")
    print(f"Defined Tags: {instance.defined_tags}")
    print(f"Freeform Tags: {instance.freeform_tags}")

    # 4. Search resources by tag
    query = f"query instance resources where (definedTags.namespace = '{TAG_NAMESPACE_NAME}' && definedTags.key = '{TAG_KEY_NAME}' && definedTags.value = '{TAG_VALUE}')"

    search_details = oci.resource_search.models.StructuredSearchDetails(
        query=query,
        type="Structured",
        matching_context_type="NONE"
    )

    search_response = search_client.search_resources(search_details)
    print(f"\nInstances in {TAG_VALUE} environment:")
    for item in search_response.data.items:
        print(f"  - {item.display_name} ({item.identifier})")

except oci.exceptions.ServiceError as e:
    print(f"Error: {e.message}")

```

--------------------------------

### Create OCI Load Balancer with Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Demonstrates the creation of an OCI load balancer using the Python SDK. This involves defining the load balancer's configuration, including shape, backend sets with health checking, and listeners. It also shows how to initiate the creation process, monitor the work request for completion, and retrieve the created load balancer's details.

```python
import oci

# Assume 'compartment_id', 'subnet_ids', and 'load_balancer' client are defined elsewhere

lb_details = oci.load_balancer.models.CreateLoadBalancerDetails(
    compartment_id=compartment_id,
    display_name="web-application-lb",
    shape_name="flexible",
    shape_details=oci.load_balancer.models.ShapeDetails(
        minimum_bandwidth_in_mbps=10,
        maximum_bandwidth_in_mbps=100
    ),
    subnet_ids=subnet_ids,
    is_private=False,
    backend_sets={
        "web-backend": oci.load_balancer.models.BackendSetDetails(
            policy="ROUND_ROBIN",
            health_checker=oci.load_balancer.models.HealthCheckerDetails(
                protocol="HTTP",
                url_path="/health",
                port=8080,
                return_code=200,
                retries=3,
                timeout_in_millis=3000,
                interval_in_millis=10000
            ),
            backends=[
                oci.load_balancer.models.BackendDetails(
                    ip_address="10.0.1.10",
                    port=8080,
                    weight=1,
                    backup=False
                ),
                oci.load_balancer.models.BackendDetails(
                    ip_address="10.0.1.11",
                    port=8080,
                    weight=1,
                    backup=False
                )
            ]
        )
    },
    listeners={
        "https-listener": oci.load_balancer.models.ListenerDetails(
            default_backend_set_name="web-backend",
            port=443,
            protocol="HTTP",
            connection_configuration=oci.load_balancer.models.ConnectionConfiguration(
                idle_timeout_in_seconds=300
            )
        )
    }
)

try:
    lb_response = load_balancer.create_load_balancer(lb_details)
    work_request_id = lb_response.headers['opc-work-request-id']
    print(f"Load Balancer creation initiated")
    print(f"Work Request ID: {work_request_id}")

    # Wait for work request to complete
    work_request = oci.wait_until(
        load_balancer,
        load_balancer.get_work_request(work_request_id),
        'lifecycle_state',
        'SUCCEEDED',
        max_wait_seconds=600
    ).data

    lb_id = work_request.load_balancer_id
    lb = load_balancer.get_load_balancer(lb_id).data

    print(f"Load Balancer Created: {lb.id}")
    print(f"IP Addresses: {[ip.ip_address for ip in lb.ip_addresses]}")
    print(f"Shape: {lb.shape_name}")
    print(f"State: {lb.lifecycle_state}")

except oci.exceptions.ServiceError as e:
    print(f"Error creating load balancer: {e.message}")
```

--------------------------------

### Initialize Load Balancer Client with OCI Python SDK

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This code snippet shows how to initialize the OCI LoadBalancerClient using configuration loaded from a file. This client is used to manage load balancers, backend sets, listeners, and health checks. It requires the OCI SDK and a valid OCI configuration file.

```python
import oci

config = oci.config.from_file()
load_balancer = oci.load_balancer.LoadBalancerClient(config)

compartment_id = "ocid1.compartment.oc1..."
subnet_ids = ["ocid1.subnet.oc1.phx...", "ocid1.subnet.oc1.phx..."]

```

--------------------------------

### Query Metrics with OCI Monitoring Client in Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Demonstrates how to query metrics data using the OCI MonitoringClient. This is useful for observing resource performance and behavior. It requires the 'oci' library and configuration with valid compartment and resource IDs.

```python
import oci
from datetime import datetime, timedelta

config = oci.config.from_file()
monitoring_client = oci.monitoring.MonitoringClient(config)

compartment_id = "ocid1.compartment.oc1..."
instance_id = "ocid1.instance.oc1.phx..."

# Example: Query CPU utilization for an instance
end_time = datetime.utcnow()
start_time = end_time - timedelta(hours=1)

metric_data_response = monitoring_client.list_metrics(
    compartment_id=compartment_id,
    namespace="oci_computeagent",
    resource_id=instance_id,
    dimensions={}, # Add dimensions if needed, e.g., {"resourceId": instance_id}
    start_time=start_time,
    end_time=end_time,
    # You might need to specify metric names, depending on what you want to query
    # For example, to get CPU utilization:
    # metric_name="CPU_UTILIZATION"
)

# Process the metric_data_response as needed
# print(metric_data_response.data)
```

--------------------------------

### Manage Block Storage Volumes using Python SDK

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet outlines the initialization for managing block storage volumes using the OCI Python SDK. It sets up the `BlockstorageClient` and `ComputeClient` and defines variables for compartment, availability domain, and instance ID, which are prerequisites for volume operations.

```python
import oci

config = oci.config.from_file()
blockstorage = oci.core.BlockstorageClient(config)
compute = oci.core.ComputeClient(config)

compartment_id = "ocid1.compartment.oc1..."
availability_domain = "AD-1"
instance_id = "ocid1.instance.oc1.phx..."

```

--------------------------------

### Load OCI SDK Configuration

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Loads the OCI SDK configuration from a file, enabling authentication for OCI services. Supports loading the default profile, a specific profile by name, or from a custom file location.

```python
import oci

# Load default profile from default location (~/.oci/config)
config = oci.config.from_file()

# Load specific profile from default location
config = oci.config.from_file(profile_name="integ-beta-profile")

# Load from custom location with specific profile
config = oci.config.from_file(
    file_location="~/.oci/config",
    profile_name="integ-beta-profile"
)

# Configuration dictionary contains:
# - user: OCID of the user
# - key_file: Path to private key file
# - fingerprint: Fingerprint of the public key
# - tenancy: OCID of the tenancy
# - region: OCI region identifier

print(f"Authenticated as user: {config['user']}")
print(f"Tenancy: {config['tenancy']}")
print(f"Region: {config['region']}")
```

--------------------------------

### OCI Object Storage Operations with Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet demonstrates common operations for OCI Object Storage using the Python SDK, including uploading, downloading, and listing objects. It utilizes the ObjectStorageClient and includes error handling for upload and download operations. Dependencies include the 'oci' SDK and standard file handling.

```python
import oci
import io

config = oci.config.from_file()
object_storage = oci.object_storage.ObjectStorageClient(config)

# Get namespace
namespace = object_storage.get_namespace().data
bucket_name = "my-application-data"
object_name = "reports/monthly-report.pdf"

# Upload an object
try:
    with open("/local/path/report.pdf", "rb") as file_data:
        put_object_response = object_storage.put_object(
            namespace_name=namespace,
            bucket_name=bucket_name,
            object_name=object_name,
            put_object_body=file_data,
            content_type="application/pdf",
            metadata={
                "department": "finance",
                "report_type": "monthly"
            }
        )
    print(f"Object uploaded: {object_name}")
    print(f"ETag: {put_object_response.headers['etag']}")

except oci.exceptions.ServiceError as e:
    print(f"Upload failed: {e.message}")

# Download an object
try:
    get_object_response = object_storage.get_object(
        namespace_name=namespace,
        bucket_name=bucket_name,
        object_name=object_name
    )

    with open("/local/path/downloaded-report.pdf", "wb") as output_file:
        for chunk in get_object_response.data.iter_content():
            output_file.write(chunk)

    print(f"Object downloaded successfully")
    print(f"Content-Type: {get_object_response.headers['content-type']}")
    print(f"Content-Length: {get_object_response.headers['content-length']}")

except oci.exceptions.ServiceError as e:
    print(f"Download failed: {e.message}")

# List objects in bucket
list_objects_response = object_storage.list_objects(
    namespace_name=namespace,
    bucket_name=bucket_name,
    prefix="reports/",
    limit=100
)

print(f"\nObjects in bucket '{bucket_name}':")
for obj in list_objects_response.data.objects:
    print(f"  - {obj.name} ({obj.size} bytes)")
```

--------------------------------

### Generate and Download Autonomous Database Wallet using Python

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet demonstrates how to generate and download an Autonomous Database wallet using the OCI Python SDK. It requires the `autonomous_database_id` and a password for the wallet. The generated wallet is saved as a zip file.

```python
import oci

database_client = oci.database.DatabaseClient(config)
autonomous_database_id = "ocid1.autonomousdatabase.oc1.phx.exampleuniqueid"
try:
    wallet_password = "SecurePassword123!"
    wallet_response = database_client.generate_autonomous_database_wallet(
        autonomous_database_id=autonomous_database_id,
        generate_autonomous_database_wallet_details=oci.database.models.GenerateAutonomousDatabaseWalletDetails(
            password=wallet_password
        )
    )

    # Save wallet to file
    with open("wallet.zip", "wb") as wallet_file:
        for chunk in wallet_response.data.iter_content():
            wallet_file.write(chunk)

    print("Wallet downloaded successfully: wallet.zip")

except oci.exceptions.ServiceError as e:
    print(f"Error generating wallet: {e.message}")
```

--------------------------------

### Download File with Streaming

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Downloads an object from object storage and streams its content directly to a local file to avoid memory issues.

```APIDOC
## GET /n/{namespaceName}/b/{bucketName}/o/{objectName}

### Description
Downloads an object from object storage and streams its content to a specified output file.

### Method
GET

### Endpoint
/n/{namespaceName}/b/{bucketName}/o/{objectName}

### Parameters
#### Path Parameters
- **namespaceName** (string) - Required - The namespace of the bucket.
- **bucketName** (string) - Required - The name of the bucket.
- **objectName** (string) - Required - The name of the object to download.

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Assuming 'namespace', 'bucket_name', 'object_storage' are defined
download_object_name = "backups/2024/backup-001.tar.gz"
output_path = "/restore/backup-001.tar.gz"

get_response = object_storage.get_object(
    namespace_name=namespace,
    bucket_name=bucket_name,
    object_name=download_object_name
)

# Stream the content to a file
with open(output_path, 'wb') as output_file:
    for chunk in get_response.data.iter_content(chunk_size=8192):
        if chunk:
            output_file.write(chunk)
```

### Response
#### Success Response (200)
- **data.iter_content(chunk_size)** (generator) - A generator yielding chunks of the object's content.
- **headers** (object) - Response headers.
  - **content-length** (string) - The size of the object in bytes.

#### Response Example
```json
{
  "data": {
    "iter_content": "<generator object>"
  },
  "headers": {
    "content-length": "1234567890"
  }
}
```

#### Error Handling
- **oci.exceptions.ServiceError** - Raised if the download fails, with attributes like `message` and `status`.
```

--------------------------------

### Manage OCI Identity and Access Management

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Interacts with OCI Identity services to retrieve user information and list users within a tenancy. Requires pre-configured OCI authentication.

```python
import oci

# Initialize configuration and identity client
config = oci.config.from_file(
    "~/.oci/config",
    "integ-beta-profile"
)
identity = oci.identity.IdentityClient(config)

# Get current user details
user_response = identity.get_user(config["user"])
user = user_response.data

print(user)
# Output structure:
# {
#   "compartment_id": "ocid1.tenancy.oc1...",
#   "description": "Integration testing user [BETA]",
#   "id": "ocid1.user.oc1...",
#   "inactive_status": null,
#   "lifecycle_state": "ACTIVE",
#   "name": "testing+integ-beta@corp.com",
#   "time_created": "2016-08-30T23:46:44.680000+00:00"
# }

# Access specific user attributes
print(f"User ID: {user.id}")
print(f"User Name: {user.name}")
print(f"Lifecycle State: {user.lifecycle_state}")
print(f"Created: {user.time_created}")

# List all users in tenancy
list_users_response = identity.list_users(compartment_id=config["tenancy"])
for u in list_users_response.data:
    print(f"User: {u.name} - State: {u.lifecycle_state}")
```

--------------------------------

### Python: Using Waiters for Asynchronous Operations in OCI SDK

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Illustrates how to use OCI SDK's waiter utilities to poll resources until they reach desired states for long-running asynchronous operations. This is crucial for managing operations that don't complete immediately.

```python
import oci
from oci.waiter import wait_until

config = oci.config.from_file()
compute = oci.core.ComputeClient(config)
blockstorage = oci.core.BlockstorageClient(config)

compartment_id = "ocid1.compartment.oc1..."
availability_domain = "AD-1"


```

--------------------------------

### Handle Paginated List Operations (Python)

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

This snippet illustrates two methods for handling paginated results from OCI SDK list operations: manual pagination using page tokens and utilizing the `list_call_get_all_results` helper function for automatic pagination. This is crucial for retrieving large datasets.

```python
import oci
from oci.pagination import list_call_get_all_results

# Assuming config is already defined
# config = oci.config.from_file()

# Example 1: Manual pagination with page token for Object Storage
object_storage = oci.object_storage.ObjectStorageClient(config)

try:
    namespace = object_storage.get_namespace().data
    bucket_name = "large-dataset-bucket"

    all_objects = []
    next_page = None

    while True:
        if next_page:
            list_response = object_storage.list_objects(
                namespace_name=namespace,
                bucket_name=bucket_name,
                limit=100,
                page=next_page
            )
        else:
            list_response = object_storage.list_objects(
                namespace_name=namespace,
                bucket_name=bucket_name,
                limit=100
            )

        all_objects.extend(list_response.data.objects)

        next_page = list_response.data.next_start_with
        if not next_page:
            break

    print(f"Total objects retrieved (manual pagination): {len(all_objects)}")
    for obj in all_objects[:10]:  # Print first 10
        print(f"  {obj.name} - {obj.size} bytes")

except oci.exceptions.ServiceError as e:
    print(f"Error listing objects: {e.message}")

# Example 2: Using pagination helpers for Object Storage and Compute
try:
    # Get all results in a single call for Object Storage
    all_objects_response = list_call_get_all_results(
        object_storage.list_objects,
        namespace_name=namespace,
        bucket_name=bucket_name
    )

    objects = all_objects_response.data.objects
    print(f"\nTotal objects retrieved (using helper): {len(objects)}")

    # Get all compute instances across all pages
    compute = oci.core.ComputeClient(config)
    compartment_id = "ocid1.compartment.oc1..."

    all_instances = list_call_get_all_results(
        compute.list_instances,
        compartment_id=compartment_id
    ).data

    print(f"\nTotal instances retrieved (using helper): {len(all_instances)}")
    for instance in all_instances[:10]: # Print first 10
        print(f"  {instance.display_name} - {instance.lifecycle_state}")

except oci.exceptions.ServiceError as e:
    print(f"Error: {e.message}")

```

--------------------------------

### Python: Custom Retry Strategy and Error Handling in OCI SDK

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Demonstrates setting up a custom retry strategy using RetryStrategyBuilder for OCI client operations. It also includes comprehensive error handling for various OCI exceptions like ServiceError, ConnectTimeout, and RequestException, with specific handling for different HTTP status codes.

```python
import oci
from oci.retry import DEFAULT_RETRY_STRATEGY, RetryStrategyBuilder
import time

config = oci.config.from_file()

# Custom retry strategy
custom_retry_strategy = RetryStrategyBuilder(
    max_attempts_check=True,
    max_attempts=5,
    total_elapsed_time_check=True,
    total_elapsed_time_seconds=300,
    retry_max_wait_between_calls_seconds=30,
    retry_base_sleep_time_seconds=2,
    exponential_backoff_base=2,
    service_error_check=True,
    service_error_retry_on_any_5xx=True,
    service_error_retry_config={
        429: [],  # Retry on rate limiting
        409: []   # Retry on conflicts
    }
).get_retry_strategy()

# Apply custom retry strategy to client
compute = oci.core.ComputeClient(config, retry_strategy=custom_retry_strategy)

instance_id = "ocid1.instance.oc1.phx..."

# Comprehensive error handling
try:
    # Attempt to get instance with retry strategy
    instance_response = compute.get_instance(instance_id)
    instance = instance_response.data
    print(f"Instance: {instance.display_name}")
    print(f"State: {instance.lifecycle_state}")

except oci.exceptions.ServiceError as e:
    # Handle specific service errors
    if e.status == 404:
        print(f"Instance not found: {instance_id}")
    elif e.status == 401:
        print(f"Authentication failed: {e.message}")
    elif e.status == 429:
        print(f"Rate limited: {e.message}")
        print(f"Retry after: {e.headers.get('retry-after', 'unknown')}")
    elif e.status >= 500:
        print(f"Server error: {e.message}")
        print(f"Request ID: {e.request_id}")
    else:
        print(f"Service error {e.status}: {e.message}")
        print(f"Code: {e.code}")
        print(f"Request ID: {e.request_id}")

except oci.exceptions.ConnectTimeout as e:
    print(f"Connection timeout: {e}")

except oci.exceptions.RequestException as e:
    print(f"Request failed: {e}")

except Exception as e:
    print(f"Unexpected error: {type(e).__name__}: {e}")

# Manual retry with backoff
max_retries = 3
retry_delay = 1

for attempt in range(max_retries):
    try:
        object_storage = oci.object_storage.ObjectStorageClient(config)
        namespace = object_storage.get_namespace().data
        print(f"Successfully retrieved namespace: {namespace}")
        break

    except oci.exceptions.ServiceError as e:
        if e.status >= 500 and attempt < max_retries - 1:
            wait_time = retry_delay * (2 ** attempt)
            print(f"Attempt {attempt + 1} failed, retrying in {wait_time}s...")
            time.sleep(wait_time)
        else:
            print(f"Failed after {attempt + 1} attempts: {e.message}")
            raise

```

--------------------------------

### Upload Large File with Progress Callback

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Uploads a large file to object storage and tracks the upload progress using a callback function.

```APIDOC
## POST /n/{namespaceName}/b/{bucketName}/o/{objectName}

### Description
Uploads a large file to a specified bucket with a progress callback.

### Method
POST

### Endpoint
/n/{namespaceName}/b/{bucketName}/o/{objectName}

### Parameters
#### Path Parameters
- **namespaceName** (string) - Required - The namespace of the bucket.
- **bucketName** (string) - Required - The name of the bucket.
- **objectName** (string) - Required - The name of the object to upload.

#### Query Parameters
None

#### Request Body
- **file_path** (string) - Required - The local path to the file to upload.
- **progress_callback** (function) - Optional - A callback function to track upload progress.
- **metadata** (object) - Optional - Metadata to associate with the object.
  - **source** (string) - Example metadata field.
  - **timestamp** (string) - Example metadata field.

### Request Example
```python
# Assuming 'namespace', 'bucket_name', 'file_path', and 'upload_manager' are defined
# and 'upload_progress_callback' is a defined function
upload_response = upload_manager.upload_file(
    namespace_name=namespace,
    bucket_name=bucket_name,
    object_name="backups/2024/backup-001.tar.gz",
    file_path="/data/large-backup.tar.gz",
    progress_callback=upload_progress_callback,
    metadata={
        "source": "database-backup",
        "timestamp": "2024-01-15T10:30:00Z"
    }
)
```

### Response
#### Success Response (200)
- **etag** (string) - The ETag of the uploaded object.
- **request_id** (string) - The ID of the request.

#### Response Example
```json
{
  "etag": "some-etag-value",
  "request_id": "some-request-id"
}
```

#### Error Handling
- **oci.exceptions.ServiceError** - Raised if the upload fails, with attributes like `message` and `status`.
```

--------------------------------

### Stream Upload from Memory

Source: https://context7.com/context7/oracle-en-us-iaas-tools-python-2.155.0/llms.txt

Uploads data from an in-memory byte stream to object storage.

```APIDOC
## POST /n/{namespaceName}/b/{bucketName}/o/{objectName}

### Description
Uploads content from a byte stream (e.g., generated data) to an object in a specified bucket.

### Method
POST

### Endpoint
/n/{namespaceName}/b/{bucketName}/o/{objectName}

### Parameters
#### Path Parameters
- **namespaceName** (string) - Required - The namespace of the bucket.
- **bucketName** (string) - Required - The name of the bucket.
- **objectName** (string) - Required - The name of the object to upload.

#### Query Parameters
None

#### Request Body
- **put_object_body** (stream) - Required - The byte stream containing the object's content.

### Request Example
```python
import io

# Create an in-memory byte stream
data_stream = io.BytesIO()
data_stream.write(b"Sample log data\n")
data_stream.seek(0)

# Assuming 'namespace', 'bucket_name', and 'object_storage' are defined
stream_response = object_storage.put_object(
    namespace_name=namespace,
    bucket_name=bucket_name,
    object_name="logs/application-log-stream.txt",
    put_object_body=data_stream
)
```

### Response
#### Success Response (200)
- **headers** (object) - Response headers, including ETag.
  - **etag** (string) - The ETag of the uploaded object.

#### Response Example
```json
{
  "headers": {
    "etag": "another-etag-value"
  }
}
```

#### Error Handling
- **oci.exceptions.ServiceError** - Raised if the stream upload fails, with attributes like `message` and `status`.
```
Tokens:
Raw