RustFS: Free Open-Source S3 Alternative Built in Rust
Object storage has become a foundational building block for modern applications, from media delivery to backups and data lakes. While AWS S3 set the standard, many teams are now looking for self-hosted, cost-efficient, and privacy-conscious alternatives. RustFS positions itself in that space: a free, open-source, S3-compatible object storage service written in Rust, designed for performance, safety, and operational simplicity.
By leveraging Rust’s memory safety guarantees and zero-cost abstractions, RustFS aims to deliver high throughput with minimal overhead, while avoiding entire classes of runtime errors common in lower-level systems.
Watch our platform overview
Buckets
Buckets in RustFS follow the familiar S3 abstraction: they are top-level containers for storing objects.
Key capabilities include:
- Creation and deletion of buckets with global namespace constraints
- Versioning support for object history and rollback
- Lifecycle rules for automated cleanup or archival
- Configurable access controls at the bucket level
The goal is full compatibility with standard S3 workflows, allowing existing tooling (CLI, SDKs) to work with minimal or no changes.
Access Keys
RustFS uses access keys to authenticate API requests, mirroring AWS S3’s model.
Each access key pair consists of:
- Access Key ID: public identifier
- Secret Access Key: private credential used for signing requests
Features include:
- Key rotation support for improved security hygiene
- Fine-grained scoping via policy attachment
- Immediate revocation without impacting other credentials
This design enables both human and programmatic access while maintaining strict security boundaries.
Policies
Policies define what actions are permitted or denied on resources within RustFS.
They are typically JSON-based documents specifying:
- Effect: Allow or Deny
- Actions: e.g.,
GetObject,PutObject - Resources: bucket or object ARNs
- Conditions: optional constraints (IP, time, etc.)
Policies can be attached to users or groups, enabling flexible permission models such as:
- Read-only public buckets
- Write-only ingestion endpoints
- Full administrative control
Users
Users represent individual identities within RustFS.
Each user can:
- Own access keys
- Be assigned policies directly
- Belong to one or more groups
This abstraction allows separation between human operators, services, and automated systems. For example, a CI pipeline can have a dedicated user with scoped permissions limited to artifact uploads.
User Groups
User groups simplify permission management at scale.
Instead of assigning policies individually, you can:
- Create groups (e.g.,
admins,readers,analytics) - Attach policies to groups
- Add users to those groups
This approach reduces duplication and enforces consistent access patterns across teams.
Running Status
Operational visibility is critical for any storage system. RustFS provides insights into its running state, including:
- Node health and uptime
- Storage utilization across disks or clusters
- Request throughput and latency metrics
- Error rates and system logs
These metrics can typically be exposed via dashboards or monitoring integrations, enabling proactive issue detection and capacity planning.
Tiers & Event Destinations
RustFS supports advanced storage workflows through tiers and event-driven integrations.
Storage Tiers
- Hot storage for frequently accessed data
- Cold/archive tiers for cost-efficient long-term retention
- Automated transitions based on lifecycle policies
Event Destinations
RustFS can emit events on object operations such as:
- Object creation (
PutObject) - Deletion
- Metadata updates
These events can be routed to:
- Message queues
- Webhooks
- Streaming systems
This enables reactive architectures—for example, triggering image processing pipelines or data ingestion workflows.
Documentation
A strong developer experience is essential for adoption. RustFS documentation typically covers:
- API reference (S3-compatible endpoints)
- Deployment guides (single node, distributed setups)
- Configuration options
- Security best practices
- SDK and CLI usage examples
Clear documentation ensures teams can onboard quickly and integrate RustFS into existing ecosystems without friction.
Conclusion
RustFS offers a compelling alternative to proprietary object storage solutions by combining S3 compatibility with the performance and safety benefits of Rust. Its feature set—buckets, access control, policies, monitoring, and eventing—covers the core needs of modern storage systems while remaining lightweight and self-hostable.
For teams seeking control over their infrastructure, predictable costs, and strong performance characteristics, RustFS is a project worth evaluating. As the ecosystem matures, it has the potential to become a serious contender in the open-source storage landscape.