Open Source Breakthrough: Scality Brings Native Object & File Storage to Kubernetes

In a move set to reshape how storage is handled in container-native environments, Scality has released open source implementations of both the Container Object Storage Interface (COSI) and Container Storage Interface (CSI) drivers. The release brings a streamlined, cloud-native approach to object and file storage provisioning in Kubernetes, addressing long-standing complexities that DevOps teams and storage architects face.

With enterprises scaling Kubernetes across hybrid and multi-cloud environments, the need for unified, standards-based storage provisioning is greater than ever. By contributing open source COSI and CSI drivers, Scality is not just modernizing storage — it’s democratizing it.

🧱 Understanding CSI and COSI: The Backbone of Kubernetes Storage

To understand the significance of this release, we need to look at what CSI and COSI actually do.

• CSI (Container Storage Interface): A standardized interface that enables Kubernetes to manage block and file storage from various vendors.

• COSI (Container Object Storage Interface): A newer spec driven by the Kubernetes SIG community that provides native support for object storage provisioning, much like how CSI does for volumes.

Until recently, COSI lacked widespread implementation — which meant object storage remained outside the direct control of Kubernetes. Scality’s contribution changes that.

🚀 What Scality’s Open Source Drivers Deliver

Scality’s newly released drivers offer plug-and-play storage integration into Kubernetes clusters. Key benefits include:

• 🔹 Native Object Storage Provisioning: Thanks to the COSI driver, DevOps teams can now treat object buckets like any other Kubernetes resource, enabling dynamic creation, management, and deletion using standard APIs.

• 🔹 Enterprise-Grade File Storage: The CSI driver connects Kubernetes to Scality’s scale-out file storage backend (and others), simplifying persistent volume provisioning across hybrid clouds.

• 🔹 Enhanced Observability: The drivers include logging and metrics support out of the box for Prometheus/Grafana integration.

• 🔹 Multi-Tenant Support: Built with enterprise use cases in mind, the drivers support multiple users, namespaces, and access control policies.

🔄 Why This Matters for DevOps and Platform Engineering

Before these drivers, managing persistent storage in Kubernetes often meant a Frankenstein stack of:

• External scripts

• Out-of-band provisioning tools

• Custom controllers

• Cloud-specific hacks

Now, teams can rely on Kubernetes-native primitives to handle storage — whether that’s attaching volumes for databases or creating object buckets for backup workflows.

This aligns with the GitOps and progressive delivery movement, where infrastructure should be declarative, observable, and governed by policy. By embracing COSI and CSI, platform teams gain:

• Faster infrastructure automation

• Consistent storage workflows across dev/test/prod

• Reduced human error and drift

• Better integration with CI/CD pipelines

🌐 Embracing Multi-Cloud Without Lock-In

Another key advantage? Freedom from vendor lock-in. Scality’s drivers are designed to support a variety of backends — not just Scality’s own storage solutions.

That means platform teams using Kubernetes on AWS, Azure, Google Cloud, or on-premise can adopt these drivers to provision storage from:

• Scality RING

• MinIO

• Ceph

• Cloud-native object storage APIs (e.g., S3-compatible systems)

In an era where data mobility and sovereignty are top concerns, open interfaces are the new competitive edge.

🔐 Open Source, Enterprise-Ready

Both drivers are available now on GitHub under the Apache 2.0 license. Scality has committed to maintaining and extending them alongside the CNCF ecosystem.

Key enterprise-ready features:

• Kubernetes 1.28+ support

• RBAC integration

• StorageClass templates for common workloads

• Helm chart deployment

• Operator compatibility

📦 Getting Started

Developers and SREs can begin using the drivers today via Helm or manual YAML manifests. Scality’s GitHub provides:

• Quickstart guides

• Helm charts

• API references

• Compatibility matrices

For production workloads, Scality offers enterprise support via its Artesca platform.

Final Take

Storage has long been the stumbling block in Kubernetes automation — too manual, too proprietary, too hard to scale. With the open sourcing of COSI and CSI drivers, Scality delivers a critical piece of the cloud-native puzzle.

For DevOps teams, it’s a chance to embrace declarative storage workflows across file and object use cases. For platform engineers, it’s a step toward unifying infrastructure under Kubernetes control — and doing it all with open, standards-based tools.