What MinIO does

MinIO is object storage that speaks Amazon's S3 API, but runs on your own hardware. This article explains what MinIO is, how to set it up, and why you would want it — for those who have no interest in a cloud provider that raises its prices once your data is in place.

Requirements

• A Linux server (Ubuntu 22.04 or newer, Debian 12, or another distro with systemd)
• MinIO Server `RELEASE.2025-04-22T22-12-26Z` or newer
• MinIO Client (`mc`) — standalone binary, no package manager needed
• A free port (default `9000` for the API, `9001` for the web interface)
• Root access or sudo

What MinIO does

MinIO stores data as objects, not as files in folders. Each object has a unique identifier, metadata, and the data itself. That model scales horizontally: if you want more space, you add a node instead of replacing a disk.

The core is S3 compatibility. Because MinIO speaks the same API as Amazon S3, existing S3 tools, SDKs, and scripts work without modifications. That is the reason MinIO runs on millions of users' systems in 2025 — from a developer with one disk to clusters feeding AI/ML workloads.

The founders — Anand Babu Periasamy, Garima Kapoor, and Harshavardhana — launched the project in November 2014 from Palo Alto. The company, MinIO, Inc., is now based in Redwood City and has raised investments from, among others, Intel Capital, SoftBank Vision Fund 2, and Dell Technologies Capital. Those names matter little to you, except for this: MinIO won't be discontinued overnight.

Why not just use S3

The question is legitimate. Amazon S3 is an excellent product with an extremely low price per gigabyte. What isn't low are the egress costs — what you pay to get your data back out. And once your data is in a bucket, leaving is an operation you'd rather not do.

MinIO runs on hardware you control. No vendor lock-in, no datacenter deciding what your storage costs. The downside: you are responsible for backups, updates, and availability. Self-hosting sounds great, until something crashes on Sunday night at 11:30 PM. Then you're not a customer waiting on the helpdesk. You are the helpdesk.

Step 1: Install MinIO Server

Download the binary and place it somewhere in your `PATH`. MinIO doesn't provide a package repository for all distros, so you fetch it directly from the downloads page.

wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/

Check if the binary works:

minio --version

You should see a version number starting with `RELEASE.2025-`. If nothing appears, you downloaded the wrong binary or a dependency is missing.

Step 2: Create the storage directory

MinIO stores objects in a directory you specify at startup. Create a dedicated directory, not your home directory:

sudo mkdir -p /data/minio
sudo useradd -r minio-user -s /sbin/nologin
sudo chown -R minio-user:minio-user /data/minio

The dedicated user isn't a formality. MinIO runs as root if you don't prevent it, and you don't want that for a service accessible over the network.

Step 3: Start the server

The simplest way to start MinIO is directly from the command line:

minio server /data/minio --address ":9000" --console-address ":9001"

The first time, MinIO generates a root user and password and prints them to the terminal. Note them down — you need them for the web interface and the client.

For a production environment, you want this running as a systemd service. Create `/etc/systemd/system/minio.service` with this content:

[Unit]
Description=MinIO Object Storage
After=network.target
[Service]
User=minio-user
Group=minio-user
ExecStart=/usr/local/bin/minio server /data/minio --address ":9000" --console-address ":9001"
Restart=always
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target

Then activate the service:

sudo systemctl daemon-reload
sudo systemctl enable minio
sudo systemctl start minio

Step 4: Install the client

The MinIO Client (`mc`) is a separate binary. It's a command-line interface that works not only with MinIO, but with any S3-compatible service — AWS S3, Cloudflare R2, you name it.

wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/

Check:

mc --version

Step 5: Configure the connection

Before `mc` can do anything, it needs to know where your server is and with which credentials. The `alias set` command saves that connection in `mc`'s configuration file:

mc alias set mijnminio http://localhost:9000 MIJN_ROOT_GEBRUIKER MIJN_ROOT_WACHTWOORD

Replace `MIJN_ROOT_GEBRUIKER` and `MIJN_ROOT_WACHTWOORD` with the credentials MinIO generated at first startup. If the server is on another machine, replace `localhost` with the IP address or hostname.

Step 6: Create and test a bucket

A bucket is the container in which objects live. Create one with `mc`:

mc mb mijnminio/testbucket

Upload a file:

mc cp /etc/hostname mijnminio/testbucket/

List the bucket's contents:

mc ls mijnminio/testbucket

You should see `hostname` in the output. That means the entire chain works: client → API → server → disk.

Step 7: Access via the web interface

MinIO's web interface runs on port `9001`. Open in your browser:

http://localhost:9001

Log in with the same root credentials. The interface offers bucket management, access policies, and an object browser. For daily administration, `mc` is faster, but the web interface is handy for those who don't have a terminal at hand.

Step 8: Set up access policies (optional)

Sharing root credentials for every application is a bad idea. Create a separate user with limited permissions:

mc admin user add mijnminio appuser eenlangwachtwoord
mc admin policy attach mijnminio readwrite --user appuser

The `readwrite` policy grants full access to all buckets. If you want a user who can only access one bucket, you need to write a custom policy. That takes time, but it prevents a compromised application from wiping your entire storage.

Verification

Check if everything works with a few commands:

mc ls mijnminio
mc admin info mijnminio

`mc ls` shows your buckets. `mc admin info` shows the server status — how many disks are active, how much space is free, and whether there are problems. Both commands should return without error messages.

Frequently asked problems

MinIO doesn't start and reports a port conflict. Port `9000` or `9001` is already in use. Check with `sudo ss -tulpn | grep 9000` which process uses the port, and choose a different port in your systemd unit or command line.

`mc` cannot connect to the server. The server might only be listening on `localhost`. Check if MinIO is running with `sudo systemctl status minio`, and whether the firewall opens port `9000`: `sudo ufw allow 9000`. If MinIO is on another machine, check whether the server listens on all interfaces — the `--address ":9000"` flag does that by default.

Root password lost. MinIO stores credentials in the config directory you specified when starting. Stop the service, move the config directory, and start again — MinIO will then generate new credentials. Your existing objects remain intact, but all access policies you had set will be reset.

What MinIO is not for

MinIO is not a replacement for your file system. It is not an NFS or SMB share that applications can write to directly. Object storage has a different API, different latency characteristics, and a different consistency model.

What MinIO is: an S3-compatible storage layer for applications built for it. The Ente server uses it to store encrypted photos. Docker Buildx can store build caches in it for faster CI/CD pipelines. Graphical clients such as Crabdrop and S3Drive give you a file manager on top of the S3 API.

The boundary is clear. For existing S3 workloads you want to bring to your own hardware, MinIO is one of the few mature open source options. For those who simply want to share a folder over the network, there are better tools.

The question is not whether MinIO is good. The question is whether you want to run the operation around it.