Compute Management¶

Omnistrate provides comprehensive compute management capabilities that abstract away cloud complexities while maintaining full control over your infrastructure. The platform manages compute resources intelligently based on your tenancy model, deployment requirements, and multi-cloud strategy.

How Omnistrate Manages Compute¶

Omnistrate's compute management is built around several key principles:

Tenant-Aware: Compute resources are allocated and managed per-tenant based on your chosen tenancy model
ACID-Compliant: All compute operations are fully ACID-compliant, ensuring no leaked resources
Versioned: All compute configurations and changes are versioned for rollback and audit capabilities
Multi-Cloud: Abstracts cloud provider differences while preserving cloud-specific optimizations
Day-2 Operations: Automates ongoing compute operations, not just initial provisioning

Compute Management by Tenancy Type¶

Dedicated Tenancy Compute Management¶

In Dedicated Tenancy (OMNISTRATE_DEDICATED_TENANCY), each tenant receives completely isolated compute infrastructure with dedicated virtual machines, storage, and network resources.

How Dedicated Compute Works¶

Infrastructure Isolation: Each tenant deployment gets its own dedicated virtual machines with no sharing at the infrastructure level. Omnistrate provisions, manages, and scales these resources independently per tenant.

Resource Allocation: Compute resources are allocated based on:

Service requirements defined in your compose specification
Customer-specific resource parameters
Performance and compliance requirements
Geographic placement preferences

Scaling Behavior: When a dedicated tenant needs more compute capacity, Omnistrate:

Provisions additional virtual machines in the same deployment cell
Configures networking and storage connectivity
Deploys and configures your service components
Updates load balancing and service discovery

Configuration Example:

x-omnistrate-service-plan:
  tenancyType: 'OMNISTRATE_DEDICATED_TENANCY'

services:
  app:
    x-omnistrate-compute:
      instanceTypes:
        - cloudProvider: aws
          name: m5.large
        - cloudProvider: gcp  
          name: n1-standard-2
        - cloudProvider: azure
          name: Standard_D2s_v3

Compute Features for Dedicated Tenancy:

Custom instance types per cloud provider
Dedicated CPU and memory allocation
Isolated storage volumes
GPU support for AI/ML workloads

Multi-Tenancy Compute Management¶

In Multi-Tenancy (OMNISTRATE_MULTI_TENANCY), multiple tenant instances share underlying compute infrastructure through intelligent bin-packing and resource optimization.

How Multi-Tenant Compute Works¶

Intelligent Bin-Packing: Omnistrate automatically places multiple tenant workloads on shared virtual machines based on:

CPU and memory requirements
Resource utilization patterns
Performance isolation requirements

Resource Isolation: While infrastructure is shared, each tenant gets:

Dedicated CPU and memory limits/requests
Isolated container runtime environments
Network-level isolation through Kubernetes namespaces
Storage isolation through persistent volume claims

Dynamic Scaling: Omnistrate continuously monitors resource utilization and:

Adds new virtual machines when capacity is exceeded
Scales down unused capacity to optimize costs
Maintains performance isolation during scaling events

Configuration Example:

x-omnistrate-service-plan:
  tenancyType: 'OMNISTRATE_MULTI_TENANCY'

services:
  app:
    platform: "linux/arm64"  # Use ARM64 for cost optimization
    deploy:
      resources:
        limits:
          cpus: '2.0'
          memory: 4G
        requests:
          cpus: '0.5'
          memory: 1G

Compute Features for Multi-Tenancy:

Automatic resource optimization and bin-packing
Configurable CPU and memory limits per tenant
Shared infrastructure with logical isolation
Cost-effective resource utilization
Automatic scaling based on aggregate demand
Platform architecture support (x86_64, ARM64)

Multi-Cloud Compute Options¶

Omnistrate provides comprehensive multi-cloud compute capabilities, allowing you to deploy and manage compute resources across multiple cloud providers seamlessly.

Supported Cloud Providers¶

Amazon Web Services (AWS)

Full range of EC2 instance types
Graviton (ARM64) and Intel/AMD (x86_64) processors
GPU instances for AI/ML workloads (P3, P4, G4, etc.)
Spot instances for cost optimization
Regional deployment across all AWS regions

Google Cloud Platform (GCP)

Compute Engine instance families
Custom machine types for precise resource allocation
GPU accelerators (NVIDIA T4, V100, A100)
Preemptible instances for cost savings
Regional deployment across GCP regions

Microsoft Azure

Virtual Machine families
ARM64 and Intel/AMD processors
Azure Spot Virtual Machines
GPU-enabled instances for compute-intensive workloads
Regional deployment across Azure regions

Instance Type Selection¶

Specify compute requirements per cloud provider:

services:
  database:
    x-omnistrate-compute:
      instanceTypes:
        - cloudProvider: aws
          name: r5.xlarge      # Memory-optimized for database
        - cloudProvider: gcp
          name: n1-highmem-4   # High memory equivalent
        - cloudProvider: azure
          name: Standard_E4s_v3 # Memory-optimized equivalent

Per-cloud instance type overrides¶

When no explicit instance type is configured, Omnistrate uses your Resource's platform value and resource requests to select suitable compute for each cloud provider. For example, platform: linux/arm64 directs Omnistrate to select ARM64-compatible defaults for supported clouds.

You can override the selected instance type for each cloud provider with x-omnistrate-compute.instanceTypes:

services:
  app:
    image: ghcr.io/example/app:latest
    platform: linux/arm64
    x-omnistrate-compute:
      instanceTypes:
        - cloudProvider: aws
          name: r7g.large
        - cloudProvider: gcp
          name: t2a-standard-4
        - cloudProvider: azure
          name: Standard_E2ps_v6
    deploy:
      resources:
        requests:
          cpus: '0.5'
          memory: 1G

Explicit instance type overrides take precedence over platform-based defaults for the cloud provider where they are defined. This also allows mixed per-cloud choices, such as AWS on ARM and GCP on x86:

services:
  app:
    image: ghcr.io/example/app:latest
    platform: linux/arm64
    x-omnistrate-compute:
      instanceTypes:
        - cloudProvider: aws
          name: r7g.large      # ARM64
        - cloudProvider: gcp
          name: n2-highmem-2   # x86_64

Instance type overrides are resource-local. Omnistrate does not inherit instanceTypes from a parent resource. In a large resource tree, add instanceTypes only to compute-backed resources that need a specific override.

If several compute-backed resources need the same selected values, define API parameters once on the parent resource and pass them to child resources with parameterDependencyMap. Each child resource still needs its own x-omnistrate-compute.instanceTypes entries that reference those API parameters.

services:
  app:
    image: omnistrate/noop
    x-omnistrate-api-params:
      - key: awsInstanceType
        description: AWS instance type
        name: AWS Instance Type
        type: String
        modifiable: false
        required: false
        export: true
        defaultValue: r7g.large
        parameterDependencyMap:
          api: awsInstanceType
          worker: awsInstanceType
      - key: gcpInstanceType
        description: GCP instance type
        name: GCP Instance Type
        type: String
        modifiable: false
        required: false
        export: true
        defaultValue: n2-highmem-2
        parameterDependencyMap:
          api: gcpInstanceType
          worker: gcpInstanceType
    depends_on:
      - api
      - worker

  api:
    image: ghcr.io/example/api:latest
    x-omnistrate-api-params:
      - key: awsInstanceType
        description: AWS instance type
        name: AWS Instance Type
        type: String
        modifiable: false
        required: true
        export: false
      - key: gcpInstanceType
        description: GCP instance type
        name: GCP Instance Type
        type: String
        modifiable: false
        required: true
        export: false
    x-omnistrate-compute:
      instanceTypes:
        - cloudProvider: aws
          apiParam: awsInstanceType
        - cloudProvider: gcp
          apiParam: gcpInstanceType

  worker:
    image: ghcr.io/example/worker:latest
    x-omnistrate-api-params:
      - key: awsInstanceType
        description: AWS instance type
        name: AWS Instance Type
        type: String
        modifiable: false
        required: true
        export: false
      - key: gcpInstanceType
        description: GCP instance type
        name: GCP Instance Type
        type: String
        modifiable: false
        required: true
        export: false
    x-omnistrate-compute:
      instanceTypes:
        - cloudProvider: aws
          apiParam: awsInstanceType
        - cloudProvider: gcp
          apiParam: gcpInstanceType

parameterDependencyMap applies only to the direct child resources listed in the map. If your dependency graph has multiple levels, map the parameter to each resource that needs the value.

When mixing architectures across clouds, publish a multi-architecture container image or ensure each selected instance type can run the container image you provide. An ARM64-only container image will not run on an x86_64 node pool, even if platform: linux/arm64 is set on the Resource.