<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Object-Storage on rHomelab</title><link>https://rhomelab.com/tags/object-storage/</link><description>Recent content in Object-Storage on rHomelab</description><generator>Hugo</generator><language>en-US</language><lastBuildDate>Mon, 16 Nov 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://rhomelab.com/tags/object-storage/index.xml" rel="self" type="application/rss+xml"/><item><title>Self-Hosted Object Storage: Running MinIO for Private S3-Compatible Storage</title><link>https://rhomelab.com/data-hoarding/minio-self-hosted-object-storage/</link><pubDate>Mon, 16 Nov 2026 00:00:00 +0000</pubDate><guid>https://rhomelab.com/data-hoarding/minio-self-hosted-object-storage/</guid><description>Everything on this site that talks to S3 (rclone, cloud cold storage, backup tools) assumes someone else&amp;#39;s bucket. MinIO lets you run that same S3 API on your own drives, with erasure coding and object locking you control.</description><content:encoded><![CDATA[<p>Every cloud cold storage guide, every rclone walkthrough, half the self-hosted apps in this stack, they all speak the same protocol underneath: S3. Not Amazon specifically, the API that Amazon happened to define first and that everyone else copied because fighting it was pointless. MinIO takes that same API and runs it on drives you own, in a rack you control, with none of the egress bills or account-suspension risk that come with someone else&rsquo;s bucket. This is that tool on its own terms: what it actually does, how it protects data at the object level instead of the filesystem level, and where it fits (and doesn&rsquo;t) next to everything else already covered on this site.</p>
<h2 id="what-minio-actually-is">What MinIO actually is</h2>
<p>MinIO is a self-hosted object storage server that implements the S3 API closely enough that nearly anything built to talk to Amazon S3 will talk to MinIO instead, just by changing an endpoint URL. You run it as a single binary or a container, point it at one or more drives, and it exposes buckets and objects over HTTP the same way S3 does: <code>PUT</code> an object, <code>GET</code> it back, list a bucket, set a lifecycle policy, none of it cares that the backend is your own hardware instead of a hyperscaler&rsquo;s data center.</p>
<p>This matters immediately for anything in this stack that already expects an S3 endpoint. Immich and several other self-hosted apps support S3 as a storage backend option. Backup tools like restic and Duplicati can write to S3 natively. rclone, <a href="/data-hoarding/rclone-sync-for-data-hoarders/">covered in its own article</a> on this site, has first-class S3 remote support. Point any of them at a local MinIO instance instead of a cloud bucket and you get the same API, the same tooling, the same mental model, but the data never leaves your network unless you decide to replicate it somewhere else on purpose.</p>
<h2 id="object-storage-is-not-a-nas-share-and-the-difference-matters">Object storage is not a NAS share, and the difference matters</h2>
<p>The <a href="/data-hoarding/nfs-vs-smb-vs-iscsi-for-data-hoarders/">NFS/SMB/iSCSI article</a> on this site covers traditional network storage: a filesystem you mount and browse, with files and directories and POSIX permissions. Object storage is a different model entirely. There&rsquo;s no directory tree, just a flat namespace of buckets containing objects, each identified by a key and addressed over HTTP, not mounted as a drive. You don&rsquo;t <code>cd</code> into a bucket and edit a file in place; you <code>PUT</code> a whole new version of the object.</p>
<p>That sounds like a limitation, and for some workloads it is. You don&rsquo;t want your Plex library living in object storage; a mounted filesystem is the right tool there, which is why this site&rsquo;s media library and NFS/SMB articles already cover that ground. But the object model buys real advantages for backup and archival data specifically: every write is atomic (an object either lands whole or doesn&rsquo;t land at all, no partial-write corruption from an interrupted copy), objects can carry versioning and immutability policies that a plain filesystem has no equivalent for, and the API-first design means anything automated (a script, a backup tool, another service) can talk to it without needing a filesystem mount at all.</p>
<h2 id="erasure-coding-raids-cousin-applied-per-object">Erasure coding: RAID&rsquo;s cousin, applied per-object</h2>
<p>Run MinIO across multiple drives or multiple nodes and it can erasure-code data the way RAID does, splitting each object into data shards and parity shards spread across the available drives, so the loss of some number of drives doesn&rsquo;t lose any objects. The actual math (how many drives you can lose without data loss, given how many total drives you&rsquo;re running) works out similarly to RAID6/RAIDZ2 style redundancy, but it&rsquo;s applied at the object level by MinIO itself rather than at the block level by the filesystem underneath.</p>
<p>This is a genuinely different redundancy layer from the ZFS pool it might be sitting on top of. If you&rsquo;ve already read the <a href="/data-hoarding/raid-redundancy-guide/">RAID redundancy guide</a> or the <a href="/data-hoarding/zfs-snapshots-for-data-hoarders/">ZFS snapshots article</a> on this site, you know ZFS gives you that protection at the block level, transparently, for anything stored on the pool. Running MinIO&rsquo;s own erasure coding on top of a ZFS pool that&rsquo;s already redundant is usually redundant in the unhelpful sense, doubling the parity overhead for no real gain. The common, sensible pattern for a single-box homelab setup is to let the underlying filesystem (ZFS, or hardware RAID) handle drive-level redundancy, and run MinIO in a simpler single-drive or single-volume mode on top, relying on the layer underneath instead of duplicating it. MinIO&rsquo;s own multi-drive erasure coding earns its keep when you&rsquo;re running MinIO across multiple separate hosts, each contributing its own drives, where no single filesystem spans the whole pool and MinIO&rsquo;s erasure coding is the only thing doing the spreading.</p>
<h2 id="versioning-and-object-lock-the-actual-draw-for-a-data-hoard">Versioning and Object Lock: the actual draw for a data hoard</h2>
<p>The feature that makes MinIO worth a dedicated setup, rather than just using a cloud bucket, is bucket versioning combined with Object Lock. Enable versioning on a bucket and every overwrite of an object keeps the previous version instead of discarding it, the same idea as a ZFS snapshot but scoped to individual objects rather than the whole dataset. Layer Object Lock on top, configured in compliance mode with a retention period, and objects become genuinely immutable for that window: not even an account with admin credentials can delete or overwrite them early, short of destroying the underlying storage entirely.</p>
<p>That&rsquo;s the real defense against the ransomware and fat-finger scenarios the <a href="/data-hoarding/3-2-1-backup-strategy/">3-2-1 backup strategy</a> article on this site warns about: a compromised backup account, or a backup tool pointed the wrong way, can still write new objects, but it cannot erase the history that&rsquo;s already locked. Several backup tools that support S3 backends (restic among them) work cleanly with Object Lock because they already write new, immutable chunks rather than modifying existing ones in place, so the locking doesn&rsquo;t fight the tool&rsquo;s own behavior.</p>
<h2 id="where-it-actually-fits-in-a-homelab-data-hoard">Where it actually fits in a homelab data hoard</h2>
<ul>
<li><strong>A local S3 target for apps that expect one.</strong> Point a self-hosted app&rsquo;s S3-compatible storage option at MinIO instead of leaving it on local disk, if that app benefits from the API (built-in presigned URLs, lifecycle rules, multi-client access) more than from a plain filesystem.</li>
<li><strong>An immutable staging point before data leaves the network.</strong> Write backups into a versioned, Object Lock-enabled MinIO bucket locally, then use rclone to replicate that bucket out to <a href="/data-hoarding/cloud-cold-storage-for-data-hoarders/">real cloud cold storage</a> for the actual off-site leg. You get local immutability and fast local restores, with the cloud tier doing what it&rsquo;s actually good for: surviving a site-level disaster.</li>
<li><strong>A private landing zone for anything you don&rsquo;t want transiting a cloud provider at all</strong>, API keys, application data dumps, anything where &ldquo;nobody outside this network ever sees it&rdquo; is a requirement rather than a preference.</li>
</ul>
<h2 id="where-it-doesnt-fit">Where it doesn&rsquo;t fit</h2>
<p>Don&rsquo;t reach for MinIO as a replacement for a NAS share. Media libraries, Time Machine-style backups, anything a human or a media server app wants to browse as a filesystem, that&rsquo;s squarely NFS/SMB/local ZFS territory, not object storage. And don&rsquo;t run it as your only copy of anything. MinIO gives you a resilient, versioned, locally-controlled storage layer, but it&rsquo;s still one site, on your own power and network, and still needs an actual off-site leg behind it to satisfy the 3-2-1 rule this site keeps coming back to. Treat it as a better local tier in that strategy, not a replacement for having a real second location.</p>
<h2 id="getting-it-running-without-overbuilding-it">Getting it running without overbuilding it</h2>
<p>For a single homelab box, the realistic starting point is a single MinIO instance in server mode pointed at a mounted ZFS or hardware-RAID volume, running as a container or systemd service, with TLS terminated by the same reverse proxy already fronting everything else in the stack (see the <a href="/self-hosted/reverse-proxy-showdown/">reverse proxy comparison</a> if that&rsquo;s not set up yet). Create a dedicated access key per application that needs one rather than sharing root credentials, enable versioning on any bucket holding backup data, and add Object Lock only where you specifically want immutability, since it&rsquo;s a one-way door: you can&rsquo;t disable compliance-mode retention early once it&rsquo;s set on an object, by design. Skip the multi-node, multi-drive erasure-coded deployment entirely unless you&rsquo;re actually running MinIO across more than one physical host; on a single box, the filesystem underneath is already doing that job.</p>
]]></content:encoded></item></channel></rss>