Self-Host MinIO: Your Own S3-Compatible Object Storage in 15 Minutes

Object storage is the backbone of modern applications. Whether you're storing backups, hosting media files, or serving assets for your web apps, Amazon S3 has become the de facto standard. But what if you want the same power without the cloud vendor lock-in or monthly bills?

MinIO is a high-performance, open-source object storage server that's fully compatible with the Amazon S3 API. In this guide, we'll deploy MinIO on your own VPS using Docker — giving you private, S3-compatible storage in about 15 minutes.

Why Self-Host MinIO?

• S3 API compatibility — Works with existing S3 SDKs, CLI tools, and applications
• Blazing fast — Written in Go, optimized for high-throughput workloads
• Privacy-first — Your data stays on your hardware, encrypted at rest
• Cost-effective — No per-request or egress fees
• Scalable — Start with a single node, scale to distributed clusters later

Prerequisites

• A VPS or dedicated server with at least 2 GB RAM and 2 CPU cores
• Docker and Docker Compose installed
• A domain or subdomain pointing to your server (e.g., minio.yourdomain.com)
• At least 20 GB free disk space for data

Step 1: Create the Docker Compose File

Create a directory for MinIO and navigate into it:

mkdir -p ~/minio && cd ~/minio
mkdir -p data config

Create a docker-compose.yml file:

version: "3.8"

services:
  minio:
    image: minio/minio:latest
    container_name: minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: your-secure-password-here
      MINIO_BROWSER_REDIRECT_URL: https://minio.yourdomain.com
    volumes:
      - ./data:/data
      - ./config:/root/.minio
    ports:
      - "9000:9000"  # S3 API
      - "9001:9001"  # Web Console
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 30s
      timeout: 20s
      retries: 3

Important: Replace your-secure-password-here with a strong password (minimum 8 characters). This is your root admin credentials.

Step 2: Launch MinIO

docker compose up -d

Check that the container is running:

docker ps | grep minio
docker logs minio

You should see output indicating the API is listening on port 9000 and the console on 9001.

Step 3: Access the Web Console

Open your browser and navigate to:

http://your-server-ip:9001

Log in with your MINIO_ROOT_USER and MINIO_ROOT_PASSWORD from the compose file.

Step 4: Create a Bucket and Access Keys

1. In the console, click Buckets → Create Bucket
2. Enter a name (e.g., my-app-backups) and click Create
3. Navigate to Access Keys → Create Access Key
4. Save the generated Access Key and Secret Key — you'll need these for S3 clients

Step 5: Test with the MinIO Client (mc)

Install the MinIO client on your local machine or server:

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

# macOS
brew install minio/stable/mc

Configure a connection alias:

mc alias set myminio http://your-server-ip:9000 admin your-secure-password

Test operations:

# List buckets
mc ls myminio

# Upload a file
mc cp myfile.txt myminio/my-app-backups/

# Download it back
mc cp myminio/my-app-backups/myfile.txt ./downloaded.txt

Step 6: (Optional) Add HTTPS with a Reverse Proxy

For production, put MinIO behind a reverse proxy like Traefik or Nginx with SSL. Here's a quick Traefik example:

# Add to your docker-compose.yml labels
labels:
  - "traefik.enable=true"
  - "traefik.http.routers.minio.rule=Host(`minio.yourdomain.com`)"
  - "traefik.http.routers.minio.entrypoints=websecure"
  - "traefik.http.routers.minio.tls.certresolver=letsencrypt"
  - "traefik.http.services.minio.loadbalancer.server.port=9001"

Verification Checklist

• [ ] MinIO container is running (docker ps)
• [ ] Web console accessible at http://IP:9001
• [ ] Can log in with root credentials
• [ ] Bucket created successfully
• [ ] mc ls lists your bucket
• [ ] File upload/download works via mc cp

Next Steps

Now that MinIO is running, here are some practical integrations:

• Backup automation — Use Restic or Borgmatic to back up to your MinIO bucket
• App storage — Point your applications to MinIO using standard S3 SDKs
• Static site hosting — Serve assets directly from MinIO buckets
• Monitoring — Add Prometheus + Grafana to track storage metrics
• Replication — Set up bucket replication to another MinIO instance for redundancy

Wrapping Up

MinIO gives you enterprise-grade object storage without enterprise-grade bills. In 15 minutes, you've deployed a fully S3-compatible server that you control — no vendor lock-in, no egress fees, complete privacy.

Whether you're backing up homelab data, building a private cloud, or developing applications that need object storage, MinIO is a rock-solid foundation.

Questions or want a specific integration guide? Drop a comment below or reach out on our contact page.