Run MinIO in Docker and Docker Compose With a Working Image

If docker pull minio/minio or quay.io/minio/minio now fails, that is expected: MinIO stopped publishing community images in October 2025. This guide runs MinIO in Docker and Docker Compose with pgsty/silo, a maintained drop-in fork that works today, and for a brand-new setup you may prefer RustFS.

Object storage is a computer data storage that manages data as objects, as opposed to other storage architectures like file systems which manages data as a file hierarchy, and block storage which manages data as blocks within sectors and tracks.

Object storage is used for housing videos and photos, music, and files for online collaboration. In object storage, data is sectioned off into units (aka “objects”) where it is stored in a flat environment. Each object includes:

Data
Metadata
Unique identifier

All data blocks for a file are contained together as an object and are stored in what is called a storage pool. To access data, the storage system uses a unique identifier and metadata to find the object. Data can be accessed using RESTful APIs, HTTP, and HTTPS.

Object storage is crucial to the functioning of cloud services and applications. And because of the way object storage works, you can scale very quickly, up to petabytes and exabytes (so long as the machine in question has the space).

MinIO is a high-performance object storage solution that provides an Amazon Web Services S3-compatible API and supports core S3 features. MinIO can run almost anywhere: public or private cloud, bare-metal infrastructure, orchestrated environments, and edge infrastructure.

In this guide, we will explore how to deploy a standalone MinIO server in Docker and Docker Compose.

Project status (as of November 2026): the MinIO community edition is no longer maintained. MinIO stopped publishing community images and binaries in October 2025, and the minio/minio and minio/mc GitHub repositories are now archived. The quay.io/minio/minio and minio/minio images can no longer be pulled anonymously, and dl.min.io returns 410 Gone. For a new setup, use RustFS instead: see How to Run RustFS Object Storage in Docker and Compose. If you already run MinIO and want to keep its data and tooling, this guide uses Silo, a maintained AGPL-3.0 fork of the MinIO server published by Pigsty as the pgsty/silo image on Docker Hub. It keeps the same server /data command, MINIO_ROOT_* credentials, ports, S3 API and on-disk data format.
Silo was called pgsty/minio until it was renamed on 2026-08-06. The old pgsty/minio image still exists but stops at RELEASE.2026-08-04T00-00-00Z and gets no further fixes, so switch to pgsty/silo if you used an earlier version of this guide. The matching client fork ships the mc tool as mcli.

Prerequisites

Before proceeding, ensure that you have Docker installed. Please check out How to Install and Use Docker Engine on Ubuntu 26.04 LTS if you need help installing.

Tip: For local development, consider binding ports to 127.0.0.1 so MinIO is not exposed on your LAN.

Start the container

Create a data directory:

mkdir -p ~/minio/data

Pick credentials. For example:

export MINIO_ROOT_USER="admin"
export MINIO_ROOT_PASSWORD="CHANGE_ME_TO_A_LONG_RANDOM_PASSWORD"

Run MinIO with Docker (standalone, single-node):

docker run \
  -d --restart unless-stopped \
  --name minio \
  -p 127.0.0.1:9000:9000 \
  -p 127.0.0.1:9090:9090 \
  -v ~/minio/data:/data \
  -e "MINIO_ROOT_USER=${MINIO_ROOT_USER}" \
  -e "MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD}" \
  docker.io/pgsty/silo:RELEASE.2026-10-26T00-00-00Z server /data --console-address ":9090"

Pinning a release tag keeps upgrades deliberate. pgsty/silo:latest also exists if you just want the newest build for local testing; check Docker Hub for the current release.

The above commands work this way:

mkdir creates a new local directory at ~/minio/data in your home directory.
docker run starts the MinIO container.
-p binds a local port to a container port.
--name creates a name for the container.
-v sets a file path as a persistent volume location for the container to use. When MinIO writes data to /data, that data mirrors to the local path ~/minio/data, allowing it to persist between container restarts. You can replace ~/minio/data with another local file location to which the user has read, write, and delete access.
-e sets MINIO_ROOT_USER and MINIO_ROOT_PASSWORD. These set the root credentials for the MinIO Console and API.

Ports and endpoints

S3 API: http://127.0.0.1:9000
MinIO Console (UI): http://127.0.0.1:9090

You can also check health endpoints:

curl -sS http://127.0.0.1:9000/minio/health/live
curl -sS http://127.0.0.1:9000/minio/health/ready

Running MinIO using Docker Compose

Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services. Then, with a single command, you create and start all the services from your configuration.

On modern Docker installations, Compose is available as a plugin via docker compose:

docker compose version

Create a working directory:

mkdir ~/minio
cd ~/minio

mkdir -p data

Create a docker-compose.yaml file:

services:
  minio:
    image: docker.io/pgsty/silo:RELEASE.2026-10-26T00-00-00Z
    command: server /data --console-address ":9090"
    restart: always
    ports:
      - "127.0.0.1:9000:9000"
      - "127.0.0.1:9090:9090"
    volumes:
      - ./data:/data
    environment:
      - MINIO_ROOT_USER=admin
      - MINIO_ROOT_PASSWORD=CHANGE_ME_TO_A_LONG_RANDOM_PASSWORD
    healthcheck:
      test: ["CMD", "silo", "healthcheck", "ready"]
      interval: 10s
      timeout: 5s
      retries: 5

Start the container:

docker compose up -d

[+] Running 2/2
 ✔ Network minio_default    Created                0.1s
 ✔ Container minio-minio-1  Started

To confirm that it is working as expected, check Compose processes:

docker compose ps
NAME                IMAGE                 COMMAND                  SERVICE             CREATED             STATUS              PORTS
minio-minio-1       pgsty/silo            "/usr/bin/docker-ent…"   minio               55 seconds ago      Up 53 seconds       127.0.0.1:9000->9000/tcp, 127.0.0.1:9090->9090/tcp

Connect your browser to the MinIO Server

Access the MinIO Console by opening:

http://127.0.0.1:9090

Port 9000 is used for the S3 API, while port 9090 is the Console/UI in this guide (because we set --console-address ":9090").

Log in to the Console with the credentials you defined in the MINIO_ROOT_USER and MINIO_ROOT_PASSWORD environment variables.

Install the MinIO Client

The MinIO Client (mc) allows you to work with your MinIO server from the command line (create buckets, upload/download, manage policies, etc). Upstream mc is archived too, so this guide uses the maintained pgsty/mc fork, which ships the same commands under the binary name mcli.

The quickest option needs no install at all: the standard pgsty/silo image bundles mcli, so you can run it inside the container:

docker exec minio mcli alias set local http://127.0.0.1:9000 "${MINIO_ROOT_USER}" "${MINIO_ROOT_PASSWORD}"
docker exec minio mcli ls local

Setting up on Linux

Download the mcli client and install it to a location on your system PATH such as /usr/local/bin. You can alternatively run the binary from the download location. Use linux_arm64 in the file name on ARM servers.

wget https://github.com/pgsty/mc/releases/download/RELEASE.2026-10-26T00-00-00Z/mcli_20261026000000.0.0_linux_amd64.tar.gz
tar xzf mcli_20261026000000.0.0_linux_amd64.tar.gz mcli
sudo install -m 0755 mcli /usr/local/bin/mcli
mcli --version

The last upstream build, mc RELEASE.2025-08-13T08-35-41Z, can still be downloaded from the archived minio/mc releases page, but it receives no fixes. Every mcli command below works the same with mc if you already have it installed.

Use mcli alias set to create a new alias associated to your local deployment. You can run mcli commands against this alias:

mcli alias set local http://127.0.0.1:9000 {MINIO_ROOT_USER} {MINIO_ROOT_PASSWORD}
mcli admin info local

Replace {MINIO_ROOT_USER} and {MINIO_ROOT_PASSWORD} with the credentials you defined for the container with the -e flags.

Create a bucket and upload a file:

mcli mb local/my-bucket
mcli cp /etc/hosts local/my-bucket/hosts.txt
mcli ls local/my-bucket

The mcli alias set command takes four arguments:

The name of the alias
The hostname or IP address and port of the MinIO server
The Access Key for a MinIO user
The Secret Key for a MinIO user

Conclusion

Each MinIO server includes its own embedded MinIO Console. In May 2025 (RELEASE.2025-05-24T17-08-30Z), upstream MinIO reduced the community Console to an object browser, removing user, policy, bucket, and configuration management, plus LDAP/OIDC logins, from the UI. Silo restores the full web console, and those tasks always work from the command line with mcli admin, for example mcli admin user add and mcli admin policy attach.