Building a GPU Cloud: Open Source vs. Integrated Operations Platforms

Published ·

Share this article:

If an operator deploys OpenStack and Kubernetes, is the commercial GPU cloud ready?

Open source can absolutely support a real GPU cloud.

OpenStack can provide infrastructure services and identity, networking, image, and compute capabilities. Ironic can provision physical bare metal machines. Kubernetes can orchestrate container workloads and expose GPUs as schedulable resources through device plugins. Prometheus, Grafana, and NVIDIA DCGM exporter can provide monitoring and GPU telemetry.

Those are substantial capabilities.

The build-versus-buy question is therefore not:

“Can open source build a GPU cloud?”

It is:

“Who will integrate and own the complete customer service workflow from order to resource recovery?”

What the Core Open Source Components Do

OpenStack and Ironic

OpenStack can provide cloud infrastructure services. Ironic is specifically a bare metal provisioning project and can manage physical machine lifecycle.

It should not be described as a complete commercial GPUaaS platform by itself.

Kubernetes

Kubernetes orchestrates container workloads and can schedule GPU resources exposed through vendor device plugins.

It also provides mechanisms such as namespaces, RBAC, and quotas that can support multi-team environments.

It is not, by itself, a customer product catalog, contract, pricing, invoice, and settlement platform.

Prometheus, Grafana, and NVIDIA DCGM exporter

DCGM exporter exposes NVIDIA GPU telemetry in Prometheus format. Prometheus stores and queries metrics, and Grafana visualizes them.

That stack is useful for infrastructure and GPU observability.

Technical telemetry is not automatically a customer billing record.

The Missing Question: Who Owns the Workflow?

Consider a customer order:

  1. choose a product
  2. validate identity and entitlement
  3. create order or reservation
  4. reserve capacity
  5. provision GPU server, network, and storage
  6. create customer access
  7. measure usage
  8. rate and bill
  9. terminate the service
  10. clean and return the resource

Each step may involve a different system.

A customer-facing operations layer of usage metering, billing, IAM, and API endpoints on top of the infrastructure tools layer.
Figure 1. In a GPU cloud, the key is the integration boundary between infrastructure and workload tools and the customer-facing commercial operations layer.

A self-built architecture can integrate these systems with custom services and APIs.

An integrated operations platform can provide more of the workflow as a unified layer.

Both are viable.

Failure States Reveal the Real Integration Cost

Suppose GPU capacity reservation succeeds, but network provisioning fails.

Who:

  • retries the network operation?
  • releases or retains the GPU reservation?
  • cleans up partially created resources?
  • reports the correct service state to the customer?
  • prevents billing from starting incorrectly?
  • returns the GPU to available capacity?
  • records the failure for audit and incident response?

This is not primarily an OpenStack-versus-Kubernetes problem.

It is a workflow ownership and state reconciliation problem.

Commercial cloud systems need to handle partial failure, retry, rollback, and billing correctness—not only the happy path.

Build vs. Integrated Platform

A fair comparison should include:

  • existing hardware integration
  • service catalog
  • order-to-fulfillment workflow
  • IAM and multi-tenancy
  • metering versus pricing and billing
  • integration APIs
  • failure and rollback ownership
  • upgrades, security, and support
  • customization
  • vendor dependency
  • internal engineering requirements
  • 3–5-year TCO

Neither approach wins automatically.

When DIY Can Be Rational

DIY can make sense when:

  • the environment is internal-only
  • the organization already has strong cloud platform engineers
  • deep customization is strategic
  • customer portal, identity, ordering, and billing systems already exist

In such cases, internal ownership may provide flexibility and control.

When an Integrated Platform Is Worth Evaluating

An integrated platform can be worth evaluating when:

  • the service is external and multi-customer
  • self-service and on-demand delivery are required
  • platform engineering capacity is limited
  • service products and SKUs are expanding
  • repeatable workflow standardization is increasingly important

License Cost Is Not TCO

Open source can reduce software license fees.

That does not make engineering, integration, testing, upgrades, security, incident response, billing integration, documentation, and support free.

Commercial platforms add license or subscription cost but may reduce some internal development burden.

The right comparison is multi-year ownership cost, not license fee alone.

Seven Questions for a CTO or Architect

  1. Who validates and maintains actual hardware, network, and storage integration?
  2. How is tenant isolation implemented across identity, network, storage, workload, and usage data?
  3. Who owns retry, rollback, and reconciliation after partial failure?
  4. Can usage and billing be audited back to customer, resource, time, contract, and rate?
  5. Who owns incident response, upgrades, security patches, and compatibility?
  6. How easily can new GPU models, SKUs, APIs, or sites be added?
  7. What is the full 3–5-year TCO including engineering, integration, operations, support, and migration?
Direct integration, with OS, K8s, and monitoring components wired together by hand, compared with an integrated operations platform that bundles catalog, billing, and console into one layer.
Figure 2. Self-built integration and an integrated platform are both viable. What matters is integration responsibility, resource lifecycle, extensibility, and 3–5-year TCO.

Where Thaki NeoCloud OS Fits

Thaki Cloud’s canonical architecture is:

Customer Infrastructure → Thaki NeoCloud OS → Customer NeoCloud Service

Thaki NeoCloud OS is the software and cloud-operations layer between customer-owned infrastructure and the operator’s own branded service.

It should not be positioned as a mandatory replacement for OpenStack or Kubernetes.

The relevant architecture question is how it integrates with the target environment and which responsibilities it takes on across service catalog, ordering, tenant operations, provisioning, metering or billing integration, failure state, and lifecycle. Actual integration and feature support must be verified for the project.

Summary

Open source can build GPU cloud infrastructure and service capabilities.

Integrated platforms can also be a valid approach.

The decision becomes clearer when the organization asks:

Who owns integration, failure recovery, lifecycle responsibility, extensibility, and multi-year TCO?

FAQ

Is OpenStack enough to build a GPU cloud?

It can be a major infrastructure foundation, but commercial product, order, billing, and service lifecycle functions may require additional components and integration.

Can Kubernetes provide GPUaaS?

Kubernetes can orchestrate and schedule GPU workloads, but customer-facing commercial lifecycle functions require additional systems.

Can Prometheus metrics be used directly for billing?

Technical metrics are not automatically billable usage records. Commercial context is required.

Is open source always cheaper?

No. Engineering and operating cost need to be included.

Does an integrated platform create vendor dependency?

It can. APIs, portability, customization, and exit strategy should be evaluated.

Share this article:

Reviewing a GPU Cloud Build-vs-Buy Decision?

If you are evaluating whether to extend an existing OpenStack / Kubernetes environment with custom commercial services or adopt an integrated operations platform, Thaki Cloud can review the architecture with you.

Contact Us