The Open Cloud Computing Interface (OCCI) is an open community-led specification for managing diverse cloud infrastructure services in a consistent and interoperable way. I provide an overview of OCCI and explore its key components, interaction mechanisms, adoption landscape, and future outlook.
Table of Contents
What is Introduction to the Open Cloud Computing Interface and its history
The Open Cloud Computing Interface, commonly abbreviated as OCCI, is a RESTful API specification for interfacing with cloud infrastructure providers in a runtime environment-agnostic fashion. In other words, it establishes a standardized protocol and best practices for deploying, monitoring, and managing compute, storage, and network resources hosted on compliant IaaS, PaaS, and serverless platforms.
The OCCI project originated circa 2010 out of the need for a common cloud API to prevent provider lock-in issues in academic research institutions across Europe. It has since evolved under the auspices of the Open Grid Forum (OGF) with contributions from global cloud technology stakeholders over the past decade.
Origins of OCCI development
The foundational research and development on OCCI began in 2010 when the European Grid Initiative (EGI) user community identified the requirement for standard cloud management interfaces. This facilitated the secure federation of academic computing infrastructures across institutional boundaries and prevented lock-in to commercial cloud vendors.
The Open Grid Forum took on the task of specifying, implementing, and promoting the adoption of OCCI to fulfill EGI’s needs. An initial integration specification was published in 2011, followed by the first official version of the OCCI core specifications in April 2012.
80+ contributors from 40+ organizations have since participated in evolving OCCI under OGF’s Standards track process.
Key goals and design principles
The OCCI framework was devised to be simple, extensible, and compatible with prevalent integration standards. Key design goals included:
- Provide a thin, easy-to-implement API with minimal dependencies
- Maintain similarity with industry standards like OVF and CDMI
- Enable seamless integration across cloud stacks using REST APIs
- Support the addition of provider-specific capabilities and features
- Facilitate federated cloud infrastructure management
The focus has always been on striking the right balance between simplicity and functionality across diverse cloud technology platforms.
Understanding the Open Cloud Computing Interface model and framework
The Open Cloud Computing Interface framework comprises an abstractly defined core model, rendering formats to communicate with compliant servers, and extension mechanisms to adapt to bespoke platforms.
The OCCI core model
The Open Cloud Computing Interface core model specifies basic types to represent cloud infrastructure elements and the relationships between them. This includes core resource types, capabilities that can be associated with resources, and links that connect resources.
For instance, compute, storage, and network are defined as core resource types. scalable, ephemeral etc. are resource capabilities. And network interface is a link type that associates compute instances with networks.
Additional resource kinds, capabilities called mixings and association types called links can be introduced through extensions. This model is then rendered in different formats like REST or OVF to interface with backends.
OCCI rendering formats
The server-side infrastructure, capabilities and policies are exposed to clients via supported rendering formats. This helps connect OCCI consumers to infrastructure providers.
The common rendering types include:
- RESTful HTTP: Uses HTTP verbs for lifecycle operations
- OVF: Renders OCCI constructs in XML as OVF descriptors
- Text: Simple line-based human-readable rendering
Currently, only the OCCI HTTP REST rendering is officially complete and supported, enabling interaction over the web or HTTP.
OCCI extensions and integration patterns
The core OCCI types act as a skeleton, while provider-specific capabilities and policies are added through extensions. Custom resource kinds, maxims and actions can be easily integrated.
Extension integration patterns include:
- In-Request: Dynamic extension handling
- Declaration: Static pre-declared extensions
- Registration: Create permanent extension records
This allows OCCI to be adapted to any platform or proprietary cloud solution via standard mechanisms.
Core Components and Functions of Open Cloud Computing Interface
Delving deeper, the core modeling elements and functionalities afforded by OCCI specifications are explained below.
OCCI Core resource types
At the heart of OCCI is the abstraction of infrastructure resources into a few basic categories:
Compute resource
The compute resource represents singular or clustered compute/container instances provisioned on cloud platforms. Details like instance type, image type, region etc. can be specified via attributes and maxims.
Operations for lifecycle management of compute instances are facilitated through the OCCI API, including deploy, start, stop, restart etc.
Network resource
The network resource models virtual L2 networks provisioned on cloud platforms to interconnect compute instances and enable external connectivity. Attributes include subnet masks, VLAN IDs, gateway etc.
Linking with compute resources enables network interface attachments. Common network operations like create, delete, attach, detach, etc. are enabled.
Storage resource
The storage resource represents block storage volumes that can be attached to compute instances, with details such as volume size, backup policy, and mount points defined as attributes.
Storage linkage with compute facilitates dynamic volume attachments. Volume create, delete, attach, detach actions are covered.
Open Cloud Computing Interface capabilities and maxims
Capabilities and business logic beyond the basic resource types are modeled as maxims. These tag resources with supplemental attributes and behaviors.
Common capabilities
Some standard maxims that can tag compute resources include:
- os_tpl: OS template (Ubuntu, RHEL etc.)
- resource_tpl: Resource template (instance types etc.)
- scalable: Horizontally scalable
And for storage resources:
- medium: HDD or SSD type
- snapshot: Snapshotting supported
- reliability: Dynamic resizing
Custom maxims
Platform-specific maxims can be defined and registered to exploit special capabilities. Eg.:
- gpu_enabled: Enable GPU hardware
- slurm_configured: Slur workload manager
This provides extreme flexibility to OCCI adaptors and extensions.
Open Cloud Computing Interface links and relationships
Links associate resources and enrich relationship semantics:
Linking resources
Links connect resources to create meaningful associations – e.g.:
- network interface: Attach compute instance to network
- storage link: Attach storage volume to compute
Association types
Each link has a type qualitative attribute describing the association:
- link::depends: Dependency relationship
- link::co-locates: Resources straddle same host
This metadata helps construct rich relational graphs of infrastructure topology.
Interacting with Open Cloud Computing Interface APIs and Implementations
On the client side, OCCI resource instances and capabilities hosted by compliant providers can be consumed and managed programmatically over the exposed interfaces:
The OCCI HTTP rendering style
The HTTP REST rendering exposes the entire OCCI feature set over a REST API binding. Common interactions patterns apply.
Core resource representations
- HTTP GET => Describe resource instances
- HTTP PUT => Instantiate new resources
- HTTP POST => Trigger actions
- HTTP DELETE => Remove resources
Custom actions and behaviors are encoded using HTTP POST semantics.
HTTP response codes
Standard HTTP codes indicate request outcomes:
- 200 OK => Success
- 400 Bad Request => Client errors
- 404 Not Found => Invalid resource URI
- 501 Not Implemented => Action not supported
This enables interfacing with any HTTP library or client SDK.
Available API client libraries
OCCI servers can be accessed programmatically using various client libraries:
Official and community-managed client libs
- Java: erocci.org (Official reference implementation)
- Python: OCCI-OS’s Python binding
- Ruby: OCCI4Ruby library
Choosing a client library
The libraries differ in feature completeness. Erucic supports the full spec, while others are works-in-progress. Erucic or OCCI-OS Python provides a good starting point.
Open Cloud Computing Interface SDK and integration tools
For providers looking to expose infrastructure over OCCI, development kits are available:
Server-side SDKs
- OCCI-OS: OpenStack middleware
- Rocca server: Ruby reference implementation
- Cockpit: System management web console
These help bootstrap OCCI endpoints on existing platforms.
Client-side integration libraries
Client-side integration libs are available for certain platforms:
- fog Gems: Enables codified cloud interactions
- Terraform provider: OCCI resources via HCL
This facilitates consumer tooling integration.
Adoption and Usage of Open Cloud Computing Interface
While initially created for scientific computing needs, OCCI has found gradual adoption across emerging edge, volunteer and utility computing landscapes:
Support in open-source cloud platforms
Integration with mainstream open source IaaS platforms is improving with community contributions – covering core lifecycle and network API capabilities so far.
OpenStack integration
The OCCI middleware plugin for OpenStack provides adapters for compute, network, and storage provisioning, authorization, and other core interactions mapped from Nova, Neutron, and Cinder.
It mediates between the OpenStack native API and the OCCI rendering for external clients. Early experimental support has also been added to Open Shift and Kubernetes OpenStack installers (Kollam, Tripleton).
Cloud stack integration
Similarly, for Cloud Stack IaaS, implementations enabling compute and network provisioning over the Cloud Monkey CLI via an OCCI adapter layer exist. This facilitates consuming Cloud stack environments with OCCI tooling.
Storage integration, permissions and resource linkage aspects are still under development.
Usage in scientific and research computing
OCCI adoption originated from the need for standardized interfaces to federate academic research computing infrastructure across institutions.
European Grid Infrastructure (EGI) Federated Cloud
The EGI Federated Cloud comprises ~60 academic data centers and computing facilities across Europe, connected via a uniform OCCI interface permitting distributed scientific workloads.
Open Science Cloud initiatives
Spanning 1.7 million CPU cores and substantial storage, the Helix Nebula Science Cloud and other European Commission sponsored initiatives also utilize OCCI for interoperability.
Besides cost savings via federation, OCCI enables the mobility of complex computing pipelines across heterogeneous HPC infrastructure.
Applicability in emerging edge and fog computing
With IoT and immersive use cases positioning distributed intelligence from core to edge, OCCI shows considerable utility in device and edge resource management.
Potential use cases and benefits
OCCI can abstract and expose capabilities of edge nodes, appliances, sensor grids, volunteer fog nodes etc. Benefits include interoperability across platforms, vertical federation and horizontal scaling.
Early prototyping has showcased OCCI’s applicability in simulation execution, media transcoding, drone fleet control and WebRTC workflows via edge infrastructure coordination.
Early stage developments
Industry collaborations under the Edge Centric Computing initiative at the Open Grid Forum are spearheading efforts around OCCI-based standards for edge resource classification, visibility, monitoring, and federation.
Implementations demonstrating OCCI integrations with Azure IoT Edge, Adriano blueprints, smart city sensor testbed, etc. have emerged recently.
As the sector matures, increased OCCI adoption is anticipated owing to its versatility across cloud, HPC, and distributed device fabrics.
Future Outlook and Ongoing Development
While OCCI has proven its utility in select application domains, mainstream adoption has room for growth. Continued mindshare growth and technology enhancements are poised to expand its footprint.
Addressing barriers to wider adoption
Historically OCCI has faced challenges around contributor developer traction beyond European organizations and inadequate information marketing.
Improving awareness and marketing
Recently the OGF OCCI working group and implementers have amped collaboration with open source bodies like OpenStack, LF Edge etc. to spur contributor growth and enterprise awareness in North America.
Targeted presentations, workshops, RFCs, and integrations to highlight OCCI’s cloud interop capabilities in edge and NFV contexts are ongoing. Collaborations with academic groups are also continuing globally.
Simplifying specifications
Complexity perceptions have also hindered uptake. Specification restructuring efforts by working towards tighter core specs with clearly defined extension integration methods is helping improve approachability.
Aligning concepts across rendering formats for consistency and modularization of capabilities is in progress. These initiatives will lower the entry bar for adopters.
Alignment with industry standards
Better integration across prevalent APIs and aligning OCCI’s model with common standards is also essential:
Relation to other interfaces
The OCCI group is collaborating with the Cloud Infrastructure Management Interface (CIMI) working group for the convergence of metadata models. Integrating curations from Terraform providers and Cloud Application Template (CAT) specifications are also being explored.
Interoperability enhancements
Mapping OCCI infrastructure constructs to established taxonomies put forth by NIST, ISO, and OpenC2 around cloud security, deployment templates, resource topologies, etc. to aid interoperability is underway.
Tooling to dynamically translate CDMI and OVF appliances to OCCI artifacts are also under assessment.
Extending Open Cloud Computing Interface for New Technologies
OCCI is being assessed for applicability in futuristic computing paradigms:
Serverless computing
Function-as-a-service implementations are emerging, with early prototypes enabling function listings, triggering, execution metrics monitoring, etc.
Natively over OCCI APIs, nationally integrated with commercial Fava’s platforms.
Artificial intelligence (AI)
Expanding OCCI for AI training systems – by introducing maxims for Machine Learning frameworks, datasets, and algorithms while allowing the attachment of GPU pools as accelerators using linkage, is also being experimented with.
Conclusion
The Open Cloud Computing Interface delivers an elegant model and platform-agnostic mechanisms for interacting with diverse cloud infrastructure and platform services via simple REST APIs and integration libraries.
While adoption beyond European academia has been gradual so far, growing support in open source cloud platforms like OpenStack and applicability for emerging edge computing standards promises to bolster its future adoption.
The continued evolution of the specifications towards modularity, user accessibility, and enterprise alignment will likely cement OCCI’s role as a driver of IaaS and PaaS interoperability.
