Open Resource Broker
by
Provides a unified API to orchestrate and provision compute capacity across AWS, Azure, Google Cloud, Kubernetes, and custom back‑ends, accessible through a CLI, REST interface, MCP server, and native SDKs for six programming languages.
Open Resource Broker Overview
What is Open Resource Broker about?
Open Resource Broker delivers a single programmable interface for requesting, tracking, and returning compute resources. It abstracts the underlying cloud or container platform, letting users define templates that describe the desired machines and then manage their lifecycle via consistent commands.
How to use Open Resource Broker?
- Install the core package (includes AWS provider) with
pip install orb-pyor add extras for other providers, e.g.,pip install "orb-py[azure]". - Run
orb initto generate aconfig.jsonand optionally configure a specific provider. - List available templates:
orb templates list. - Request machines:
orb machines request <template-id> <count>. - Check request status:
orb requests status <request-id>. - Return machines when finished:
orb machines return <machine-id> …. - For programmatic access, use the Python SDK (
from orb import ORBClient) or any of the other language SDKs. A REST API can be started withorb mcp serve --port 3000(or--stdiofor AI assistants).
Key features of Open Resource Broker
- Multi‑cloud provider support: AWS (EC2, Spot, ASG, Lambda MicroVM), Azure (VM Scale Sets, CycleCloud), Google Cloud (Managed Instance Groups, Compute Engine), Kubernetes (Pod, Deployment, StatefulSet, Job) and extensible custom providers.
- Multiple interaction modes: CLI, REST API server, MCP server for AI assistants, and native SDKs for Python, Go, TypeScript, Java, Kotlin, .NET.
- Template‑driven provisioning: Define reusable compute specifications in JSON/YAML templates.
- Scheduler integration: Works with default native scheduler, IBM Spectrum Symphony HostFactory, Slurm, HTC‑Grid, OpenGRIS Scaler.
- Extensible architecture: Clean Architecture with DDD and CQRS; providers and schedulers are plug‑in strategies.
- Observability options: Optional monitoring extras for AWS and a full monitoring stack.
Use cases of Open Resource Broker
- Auto‑scaling test environments: Spin up identical VM clusters on demand for CI/CD pipelines.
- Hybrid cloud workloads: Deploy workloads on the most cost‑effective cloud provider without changing code.
- AI‑assistant‑driven operations: Enable an AI assistant to provision resources via the MCP server.
- Batch processing on Slurm or HTC‑Grid: Submit compute jobs from a unified interface regardless of underlying scheduler.
- Kubernetes‑native batch jobs: Provision Jobs or StatefulSets on a Kubernetes cluster using templates.
FAQ from the Open Resource Broker
Q: Do I need to install all provider extras?
A: No. The core install includes the AWS provider. Install other providers only when needed, e.g., pip install "orb-py[azure]".
Q: What Python version is required? A: Python 3.10 or newer.
Q: How does the MCP server start?
A: orb mcp serve --stdio for AI‑assistant integration or orb mcp serve --port 3000 --host localhost for a TCP server.
Q: Can I run Open Resource Broker inside a container?
A: Yes. Use the provided Docker Compose setup: clone the repo, copy .env.example to .env, adjust variables, then docker-compose up -d.
Q: How are credentials handled? A: Each provider follows its native credential chain (AWS CLI profiles, Azure DefaultAzureCredential, Google ADC, Kubernetes kubeconfig or in‑cluster service account).
Q: Is there support for custom providers?
A: Yes. Implement a provider strategy and register it via the orb.providers entry‑point group.
Q: Where can I find the SDK documentation?
A: See the “SDKs” section in the README or the docs at docs/root/sdk/index.md for each language.
Open Resource Broker's README
Open Resource Broker (ORB) is a unified API for orchestrating and provisioning compute capacity programmatically. Define what you need in a template, request it, track it, return it — through a CLI, REST API, MCP server, or native SDKs in six languages (Python, Go, TypeScript, Java, Kotlin, .NET).
ORB ships with provider backends for AWS, Azure, Google Cloud, and Kubernetes, plus an extensible provider system for adding new backends.
Provider support:
- AWS — EC2 RunInstances, EC2Fleet, SpotFleet, Auto Scaling Groups, Lambda MicroVMs (built in; see AWS Provider Setup below)
- Azure — VM Scale Sets, single VMs, CycleCloud cluster nodes (
pip install "orb-py[azure]"; see Azure Provider Guide) - Google Cloud — Managed Instance Groups, single Compute Engine VMs (
pip install "orb-py[gcp]"; see Google Cloud Provider Guide) - Kubernetes — Pod, Deployment, StatefulSet, Job (
pip install "orb-py[k8s]"; see Kubernetes provider docs) - Custom — extensible via provider registry and the
orb.providersentry-point group
Scheduler support:
- Default — direct usage without an external scheduler, via ORB's native request/machine API
- IBM Spectrum Symphony (HostFactory) — see HostFactory Integration
- Slurm Workload Manager by SchedMD — integrates via ResumeProgram/SuspendProgram power hooks; see Slurm Integration Guide
- HTC-Grid and OpenGRIS Scaler — these grid schedulers consume ORB through the default scheduler's native API rather than a dedicated ORB scheduler strategy; see HTC-Grid and OpenGRIS Scaler
Quick Start
pip install orb-py
orb init
orb templates generate
1. Pick a template
orb templates list
2. Request machines
orb machines request <template-id> 3
3. Check status
orb requests status <request-id>
4. Return machines when done
orb machines return <machine-id-1> <machine-id-2> ...
5. Check the return status
machines return prints a return-request id; check it the same way as step 3:
orb requests status <return-request-id>
Setup
Get ORB installed and configured for your environment.
Standard install (core + AWS provider)
pip install orb-py
boto3/botocore are core dependencies, so the base install already includes the AWS provider. pip install "orb-py[aws]" installs the same packages — it is an explicit, forward-compatible alias for operators who prefer to name providers by extra. Azure, Google Cloud, and Kubernetes each need their own extra below.
ORB still boots cleanly when no provider is configured in config.json: commands that need a provider return a clear "no providers configured" error rather than an ImportError.
Per-provider install
pip install "orb-py[aws]" # AWS provider — same deps as the base install, explicit opt-in
pip install "orb-py[azure]" # Azure provider (azure-identity, azure-mgmt-compute, ...)
pip install "orb-py[gcp]" # Google Cloud provider (google-cloud-compute)
pip install "orb-py[k8s]" # Kubernetes provider (kubernetes SDK)
pip install "orb-py[aws,cli]" # AWS provider + colored CLI output
pip install "orb-py[aws,api]" # AWS provider + REST API server
pip install "orb-py[monitoring-aws]" # AWS provider + full monitoring stack
pip install "orb-py[all]" # All providers + all features
Provider extras matrix
| Use case | Install command |
|---|---|
| Core (includes AWS provider) | pip install orb-py |
| AWS operator (explicit extra) | pip install "orb-py[aws]" |
| Azure operator | pip install "orb-py[azure]" |
| Google Cloud operator | pip install "orb-py[gcp]" |
| Kubernetes operator | pip install "orb-py[k8s]" |
| AWS + Kubernetes | pip install "orb-py[aws,k8s]" |
| AWS + colored CLI | pip install "orb-py[aws,cli]" |
| AWS + REST API | pip install "orb-py[aws,api]" |
| AWS + monitoring | pip install "orb-py[monitoring-aws]" |
| Full (all providers + features) | pip install "orb-py[all]" |
With colored CLI output
pip install "orb-py[cli]"
With REST API server
pip install "orb-py[api]"
With monitoring and observability
pip install "orb-py[monitoring]"
Full install (all extras)
pip install "orb-py[all]"
Requires Python 3.10+.
orb init creates a config.json in a location based on your install type (virtualenv, user install, system install, or development checkout). Override with:
export ORB_CONFIG_DIR=/path/to/config
| Variable | Description |
|---|---|
ORB_ROOT_DIR |
Set base directory for all subdirs (config, work, logs, health, scripts) |
ORB_CONFIG_DIR |
Override config directory path (takes precedence over ORB_ROOT_DIR) |
ORB_WORK_DIR |
Override work directory path (takes precedence over ORB_ROOT_DIR) |
ORB_LOG_DIR |
Override logs directory path (takes precedence over ORB_ROOT_DIR) |
ORB_HEALTH_DIR |
Override health directory path (takes precedence over ORB_ROOT_DIR) |
ORB_LOG_LEVEL |
Logging level: DEBUG, INFO, WARNING, ERROR |
See the Configuration Guide for path resolution details, environment variables, and REST API server setup.
ORB uses boto3's standard credential chain — any method that works with the AWS CLI works with ORB.
# Verify your credentials are active
aws sts get-caller-identity
Supported credential methods: AWS CLI profiles, environment variables (AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY), IAM instance profiles, SSO (aws sso login), and credential process.
Supported resource types
| Type | Description |
|---|---|
RunInstances |
Direct EC2 instance provisioning |
EC2Fleet |
Fleet provisioning with mixed instance types |
SpotFleet |
Cost-optimized spot instance fleets |
AutoScalingGroup |
Managed scaling groups |
MicroVM |
Isolated Lambda MicroVM sandboxes for untrusted code |
See the AWS Provider Guide for required IAM permissions and SpotFleet service-linked role setup. See the MicroVM Provider Guide for Lambda MicroVM setup.
ORB uses Azure's DefaultAzureCredential chain — any method that works with the Azure CLI works with ORB.
# Verify your credentials are active
az account show
Install with pip install "orb-py[azure]", then run orb init --provider-type azure. See the Azure Provider Guide for supported resource types, credential methods, and the configuration reference.
ORB uses Google's Application Default Credentials (ADC) — any method that works with gcloud works with ORB.
# Verify your credentials are active
gcloud auth application-default print-access-token
Install with pip install "orb-py[gcp]", then run orb init --provider-type gcp. See the Google Cloud Provider Guide for supported resource types, credential methods, and the configuration reference.
ORB uses the standard Kubernetes client credential chain — any context that works with kubectl works with ORB. Running in-cluster, it auto-detects the mounted service account; running outside, it reads your KUBECONFIG and current context.
# Verify your context is active
kubectl config current-context
Supported credential methods: KUBECONFIG contexts, the default ~/.kube/config, and in-cluster service accounts (auto-detected). See provider discovery for the detection order.
Supported resource types
| Type | Description |
|---|---|
Pod |
Single-pod provisioning |
Deployment |
Replica-managed stateless workloads |
StatefulSet |
Stable-identity stateful workloads |
Job |
Run-to-completion batch workloads |
Install with pip install "orb-py[k8s]". Minimum RBAC is in docs/root/providers/k8s/rbac.yaml; see the Kubernetes Provider Guide for full setup.
Interfaces
ORB provides multiple ways to interact with your infrastructure — a CLI, a REST API, an MCP server, and native SDKs in six languages.
All available commands and flags.
| Command | Description |
|---|---|
orb init |
Initialize config and discover AWS infrastructure |
orb init --non-interactive |
Initialize without interactive prompts |
orb templates generate |
Generate example templates for your provider |
orb templates list |
List available templates |
orb templates list --format table |
Table view |
orb templates show <template-id> |
Show a single template |
orb templates validate --file <file> |
Validate a template file |
orb machines request <template-id> <n> |
Request n machines |
orb machines list |
List active machines |
orb machines return <machine-id> [...] |
Return one or more machines |
orb requests status <request-id> |
Check request status |
orb requests list |
List all requests |
orb infrastructure show |
Show configured infrastructure |
orb infrastructure discover |
Scan AWS for VPCs, subnets, security groups |
orb infrastructure validate |
Verify infrastructure still exists in AWS |
orb config show |
Show current configuration |
orb config validate |
Validate configuration |
orb providers list |
List configured providers |
orb system health |
System health check |
orb system health --detailed |
Detailed health check |
Request status values: pending, in_progress, completed, failed, cancelled, partial, timeout.
See the CLI Reference for the full flag reference.
Example API calls. Requires pip install "orb-py[api]" and orb server start (add --foreground for an in-shell variant).
# Get available templates
curl -X GET "http://localhost:8000/api/v1/templates"
# Create machine request
curl -X POST "http://localhost:8000/api/v1/requests" \
-H "Content-Type: application/json" \
-d '{"templateId": "my-template", "maxNumber": 5}'
# Check request status
curl -X GET "http://localhost:8000/api/v1/requests/req-12345"
Native client libraries in six languages. Python is async-first and in-process; the other five drive a managed orb server over a local socket, so they share one OpenAPI contract and behave identically.
| Language | Install | Entry point |
|---|---|---|
| Python | pip install orb-py |
orb.ORBClient |
| Go | go get github.com/finos/open-resource-broker/sdk/go |
orb.Client |
| TypeScript / Node | npm install @finos/open-resource-broker |
OrbClient |
| Java | org.finos.openresourcebroker:open-resource-broker-java |
OrbClient |
| Kotlin | org.finos.openresourcebroker:open-resource-broker-kotlin |
OrbClient |
| .NET / C# | dotnet add package FINOS.OpenResourceBroker |
OrbClient |
from orb import ORBClient as orb
async with orb(provider="aws") as sdk:
templates = await sdk.list_templates(active_only=True)
request = await sdk.request_machines(
template_id=templates["templates"][0]["template_id"],
count=3,
)
status = await sdk.get_request_status(request_id=request["request_id"])
See the SDK documentation for per-language install and usage guides, the Python SDK Quickstart, and Generate Your Own SDK.
ORB provides a Model Context Protocol (MCP) server for AI assistant integration:
# Start MCP server in stdio mode (for AI assistants)
orb mcp serve --stdio
# Start as TCP server (for development/testing)
orb mcp serve --port 3000 --host localhost
Available MCP Tools:
- Provider Management:
check_provider_health,list_providers,get_provider_config - Template Operations:
list_templates,get_template,validate_template - Infrastructure Requests:
request_machines,get_request_status,return_machines
Available MCP Resources:
templates://— Available compute templatesrequests://— Provisioning requestsmachines://— Compute instancesproviders://— Cloud providers
Claude Desktop Configuration:
{
"mcpServers": {
"open-resource-broker": {
"command": "orb",
"args": ["mcp", "serve", "--stdio"]
}
}
}
Integrations
Connect ORB to schedulers and container platforms.
ORB integrates with IBM Spectrum Symphony as a HostFactory provider plugin, providing full API compatibility through shell scripts:
| Script | Description |
|---|---|
getAvailableTemplates.sh |
List available compute templates |
requestMachines.sh |
Request new compute instances |
getRequestStatus.sh |
Poll request status |
requestReturnMachines.sh |
Return instances |
getReturnRequests.sh |
Check return request status |
Scripts are available for both Linux (bash) and Windows (bat). They are generated automatically by orb init and placed in your config directory.
Key features:
- Full HostFactory API compatibility
- Automatic CPU and RAM attribute generation from AWS instance types
- Native HostFactory output format (camelCase JSON)
- Drop-in replacement for existing provider plugins
Example template output:
{
"templates": [
{
"templateId": "t3-medium-template",
"maxNumber": 5,
"attributes": {
"type": ["String", "X86_64"],
"ncpus": ["Numeric", "2"],
"nram": ["Numeric", "4096"]
}
}
]
}
See the HostFactory Guide for full integration details.
Run ORB as a containerized service.
git clone https://github.com/finos/open-resource-broker.git
cd open-resource-broker
cp .env.example .env
# Edit .env with your configuration
docker-compose up -d
curl http://localhost:8000/health
The k8s-legacy module is a Spectrum Symphony HostFactory custom provider plugin for Kubernetes, predating the modern multi-cloud ORB architecture. It is now bundled with orb-py as an optional install extra rather than as a separate PyPI package.
Install with:
pip install "orb-py[k8s-legacy]"
Confirm the install by listing available templates:
orb k8s-legacy get-available-templates
The plugin is in maintenance mode. A modern Kubernetes provider with native ORB integration is in development; existing deployments remain fully supported.
- Upgrading from
open-resource-broker? See the migration guide. - Deploying the Spectrum Symphony HF plugin? See the k8s-legacy deployment guide.
Project
Architecture, development, and documentation.
ORB is built on Clean Architecture with Domain-Driven Design (DDD) and CQRS:
- Domain layer — pure business logic, no infrastructure dependencies
- Application layer — command/query handlers using abstract ports
- Infrastructure layer — AWS adapters, DI container, storage strategies
- Interface layer — CLI, REST API, MCP server
The provider system uses a Strategy/Registry pattern — each cloud provider (AWS, future providers) registers its own strategy, handlers, and template format. The scheduler system uses the same pattern — HostFactory and Default schedulers are interchangeable strategies behind a common port.
See the Architecture Guide for details.
Set up a local development environment.
git clone https://github.com/finos/open-resource-broker.git
cd open-resource-broker
python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"
Run the test suite:
make test
Lint and format:
make lint
make format
See CONTRIBUTING.md for the full development guide.
- Quick Start
- CLI Reference
- Configuration Guide
- Template Management
- Troubleshooting
- Architecture
- API Reference
- Deployment
- DeepWiki — AI-generated codebase documentation
Full docs: finos.github.io/open-resource-broker
License
Apache License 2.0 — see LICENSE.
Security
See SECURITY.md for responsible disclosure procedures.
Open Resource Broker Reviews
Login Required
Please log in to share your review and rating for this MCP.
Similar MCP Servers like Open Resource Broker
Explore related MCPs that share similar capabilities and solve comparable challenges
Webiny
by webiny
A self‑hosted, serverless CMS platform built on AWS that enables developers to extend content management with TypeScript code and AI‑assisted tooling.
Aws Mcp Servers
Officialby awslabs
Provides specialized servers that expose AWS capabilities through the Model Context Protocol, enabling AI assistants to retrieve up-to-date documentation, execute API calls, and automate infrastructure workflows directly within development environments.
Cloudflare MCP Server
by cloudflare
Provides a collection of Model Context Protocol servers that enable MCP‑compatible clients to interact with Cloudflare services such as Workers, Observability, Radar, and more, allowing natural‑language driven management of configurations, data, and operations.
Agent Toolkit For AWS
by aws
Enables AI coding agents to work with AWS services by providing built‑in plugins, skill libraries, and an MCP server that offers full API access, sandboxed script execution, and real‑time documentation search.
MCP Server Kubernetes
by Flux159
Connects to a Kubernetes cluster and offers a unified MCP interface for kubectl, Helm, port‑forwarding, diagnostics, and non‑destructive read‑only mode.
Oracle MCP Server Repository
by oracle
Provides reference implementations of Model Context Protocol servers that enable standardized, language‑agnostic interactions with Oracle cloud services and products.
Run Model Context Protocol Servers With AWS Lambda
by awslabs
Wrap existing stdio‑based MCP servers to run as AWS Lambda functions, exposing them via HTTPS, API Gateway, Bedrock AgentCore, Lambda function URLs or the Lambda Invoke API.
EdgeOne Pages MCP
by TencentEdgeOne
Deploy HTML, folders, or zip archives to EdgeOne Pages and instantly obtain a public URL for fast edge delivery.
Volcengine MCP Servers
by volcengine
A comprehensive collection of Model Context Protocol (MCP) servers that expose Volcengine cloud resources and third‑party services through natural‑language interfaces, enabling AI‑driven operations across compute, storage, databases, networking, security, and developer utilities.