Oracle OCI Compute

Overview

Oracle Cloud Infrastructure (OCI) Compute offers a range of compute services designed to support diverse application requirements, from general-purpose web servers to high-performance computing (HPC) clusters. OCI Compute provides options for virtual machines (VMs), bare metal instances, and dedicated virtual hosts, allowing users to select the underlying infrastructure that best fits their workload's performance, isolation, and cost needs Oracle Compute overview. The service aims to deliver consistent high performance and predictable pricing, which can be beneficial for enterprises migrating existing on-premises applications to the cloud.

OCI Compute instances are available across various processor architectures, including Intel, AMD, and ARM (Ampere A1), enabling optimization for specific software stacks. For demanding workloads, Oracle provides specialized GPU instances for machine learning and graphics-intensive applications, as well as HPC instances optimized for low-latency networking and high-throughput data processing Oracle Cloud Compute homepage. The platform supports a variety of operating systems, including Oracle Linux, CentOS, Ubuntu, Windows Server, and custom images, providing flexibility for deployment.

OCI's compute offerings are often utilized by organizations with significant Oracle database deployments, enabling tighter integration and potentially optimized performance for Oracle software. The platform's focus on enterprise-grade performance and security features also makes it suitable for regulated industries that require specific compliance certifications Oracle Cloud Infrastructure Compliance. Furthermore, OCI's commitment to hybrid cloud strategies extends to its compute services, facilitating consistent development and deployment environments between on-premises data centers and the OCI public cloud.

The developer experience with OCI Compute is supported by comprehensive SDKs in multiple languages, a command-line interface (CLI) for automation, and a web-based console for graphical management. While the documentation is extensive, its breadth can require a learning curve for new users. Features like instance pools and auto-scaling groups help manage fluctuating demand and ensure application availability. Oracle's approach to compute infrastructure emphasizes raw performance and predictable resource allocation, which contrasts with some other providers that prioritize highly abstracted, serverless compute models.

Key features

• Virtual Machines (VMs): Configurable compute instances supporting various operating systems, processor architectures (Intel, AMD, ARM), and resource allocations.
• Bare Metal Instances: Dedicated physical servers providing full control over hardware and maximum performance isolation, suitable for high-performance computing and latency-sensitive applications.
• Container Instances: Serverless compute for running containers without managing the underlying virtual machines or infrastructure, simplifying deployment of containerized applications.
• Dedicated Virtual Hosts: Provides a single-tenant host for running multiple VMs, offering a balance between VM flexibility and bare metal isolation.
• GPU Instances: Compute instances equipped with NVIDIA GPUs, designed for machine learning, deep learning, and graphical rendering workloads.
• HPC Instances: Optimized compute instances with high-bandwidth, low-latency networking (RDMA over Converged Ethernet - RoCE) for demanding scientific and engineering workloads.
• Instance Pools and Auto Scaling: Automates the creation and termination of compute instances based on defined policies and real-time demand, ensuring application availability and cost efficiency.
• Custom Images: Users can create and manage custom machine images to standardize deployments and ensure consistent environments.
• Hybrid Cloud Options: Integration points and consistent services for extending on-premises environments to OCI, supporting hybrid cloud deployments.
• Extensive SDKs and API: Programmatic access to manage compute resources using SDKs for Java, Python, Go, Ruby, .NET, TypeScript/JavaScript, and PHP, alongside a REST API OCI Compute API Reference.

Pricing

OCI Compute pricing operates on a pay-as-you-go model, where users are charged for compute resources consumed. Costs vary based on instance type (VM, bare metal), processor architecture (Intel, AMD, ARM), CPU core count, memory, and any attached GPU resources. Sustained use discounts are automatically applied for long-running instances, and customers can also opt for reserved instances to achieve lower rates for predictable workloads with commitments of one or three years. The Always Free tier includes specific micro instances and up to four ARM-based Ampere A1 cores with 24GB of RAM Oracle Cloud Price List.

Common integrations

• Oracle Autonomous Database: Direct integration for high-performance database access and application deployment Oracle Autonomous Database overview.
• Oracle Container Engine for Kubernetes (OKE): Compute instances can serve as worker nodes for OKE clusters, enabling container orchestration Oracle Container Engine for Kubernetes.
• Oracle Cloud Infrastructure Identity and Access Management (IAM): Controls access to compute resources and actions through policies OCI IAM overview.
• Oracle Cloud Infrastructure Monitoring: Collects metrics and provides alarms for compute instance performance and health OCI Monitoring.
• Terraform: Used for Infrastructure as Code (IaC) to provision and manage OCI Compute resources Terraform with OCI.
• Ansible: Automates configuration management and application deployment on OCI Compute instances Ansible with OCI.
• Grafana / Prometheus: Can integrate with OCI Monitoring for advanced visualization and alerting of compute metrics, as discussed in general monitoring best practices Datadog State of Serverless.

Alternatives

• Amazon EC2: A widely used compute service offering a broad spectrum of instance types, operating systems, and global regions.
• Google Compute Engine: Provides virtual machines with custom machine types, live migration, and a strong focus on containerization and analytics integration.
• Azure Virtual Machines: Microsoft's offering for scalable compute capacity, with deep integration into the Windows ecosystem and hybrid cloud solutions.
• DigitalOcean Droplets: Simplified virtual machines designed for developers, known for ease of use and predictable pricing.
• Hetzner Cloud Servers: Cost-effective European cloud provider offering dedicated and virtual servers, popular for budget-conscious deployments.

Getting started

To provision a basic virtual machine using the OCI Python SDK, you first need to set up your OCI configuration file and ensure you have the necessary authentication credentials. This example creates a VM.Standard.E4.Flex instance using an Oracle Linux image in a specified compartment and VCN subnet.

import oci

# OCI Configuration - Assumes default profile and config file at ~/.oci/config
config = oci.config.from_file()
compute_client = oci.core.ComputeClient(config)

# Define your compartment OCID and subnet OCID
compartment_id = "ocid1.compartment.oc1..exampleuniqueID"
subnet_id = "ocid1.subnet.oc1.phx.exampleuniqueID"

# Image OCID for Oracle Linux 8 (Update for your region/latest version)
# You can find image OCIDs in the OCI Console or documentation
image_id = "ocid1.image.oc1.phx.exampleuniqueIDforOracleLinux8"

# Shape for the instance (e.g., Flexible E4 shape)
# Adjust OCPU and memory based on your needs
instance_shape = "VM.Standard.E4.Flex"
shape_config = oci.core.models.LaunchInstanceShapeConfig(
    ocpus=1,
    memory_in_gbs=16
)

# Create a launch instance details object
launch_instance_details = oci.core.models.LaunchInstanceDetails(
    compartment_id=compartment_id,
    display_name="my-first-oci-vm",
    shape=instance_shape,
    image_id=image_id,
    subnet_id=subnet_id,
    create_vnic_details=oci.core.models.CreateVnicDetails(subnet_id=subnet_id),
    metadata={
        "ssh_authorized_keys": "ssh-rsa AAAA...yourPublicKeyHere...user@host"
    },
    shape_config=shape_config
)

# Launch the instance
try:
    print(f"Launching instance '{launch_instance_details.display_name}'...")
    launch_response = compute_client.launch_instance(launch_instance_details)
    instance = launch_response.data
    print(f"Instance '{instance.display_name}' launched with OCID: {instance.id}")
    print(f"Current state: {instance.lifecycle_state}")
except oci.exceptions.ServiceError as e:
    print(f"Error launching instance: {e}")

Before running this code, replace the placeholder OCIDs for compartment_id, subnet_id, and image_id with your actual values. Also, ensure your SSH public key is correctly placed in the ssh_authorized_keys metadata field for SSH access. You can find up-to-date image OCIDs in the OCI console or documentation for your specific region OCI Compute Images.