Minio : Programatically Creating a bucket (Docker)

For my development team it is important that we are able to build out containers and have everything ready to go out of the box. In my searches I was able to find lots of documentation on how to add Minio to your development stack but no documentation whatsoever on how to create your bucket programatically.

When creating a development stack for Laravel, it’s common practice to have seeders that populate your database with dummy content, this could include artwork and other media files as it does in our case, but these seeders are no good if you have to manually create your bucket every time you need to rebuild your environment.

So i’ve put this snippet together to demonstrate how you can programatically create a bucket in your docker compose and also how to make that bucket fully public.

Here we just have a standard Laravel Sail app setup. There isn’t anything out of the ordinary here, the key being that you add minio as a dependency so that we have a minio container before we attempt to execute programatically creating a bucket.

Basic App

version: '3'
services:
  my-app.test:
    build:
      context: "./docker/my-app" # path to where your docker setup files are located
      dockerfile: Dockerfile # the docker file for that app
      args:
        WWWGROUP: '${WWWGROUP}' # any arguments you want to pass
    image: sail-8.1/app-1 # the name of your image
    extra_hosts:
      - 'host.docker.internal:host-gateway'
    ports:
      - '${APP_PORT:-80}:80' # the port your app runs from
    env_file:
      - './.env' # i tend to use an file to import my environment variables
    environment:
      APP_SERVICE: 'my-app'
      XDEBUG_MODE: '${SAIL_XDEBUG_MODE:-off}'
      XDEBUG_CONFIG: '${SAIL_XDEBUG_CONFIG:-client_host=host.docker.internal}'
    volumes:
      - '${APP_PATH}:/var/www/html'
    networks:
      - sail
    depends_on:
      - mariadb
      - redis
      - minio # include minio in your build

version: '3'

services:

my-app.test:

build:

context: "./docker/my-app" # path to where your docker setup files are located

dockerfile: Dockerfile # the docker file for that app

args:

WWWGROUP: '${WWWGROUP}' # any arguments you want to pass

image: sail-8.1/app-1 # the name of your image

extra_hosts:

- 'host.docker.internal:host-gateway'

ports:

- '${APP_PORT:-80}:80' # the port your app runs from

env_file:

- './.env' # i tend to use an file to import my environment variables

environment:

APP_SERVICE: 'my-app'

XDEBUG_MODE: '${SAIL_XDEBUG_MODE:-off}'

XDEBUG_CONFIG: '${SAIL_XDEBUG_CONFIG:-client_host=host.docker.internal}'

volumes:

- '${APP_PATH}:/var/www/html'

networks:

- sail

depends_on:

- mariadb

- redis

- minio # include minio in your build

Basic Minio Image Setup

Next we add our Minio image with default configuration.

  minio:
    image: 'minio/minio:latest'
    ports:
      - '${FORWARD_MINIO_PORT:-9000}:9000'
      - '${FORWARD_MINIO_CONSOLE_PORT:-8900}:8900'
    environment:
      MINIO_ROOT_USER: 'sail'
      MINIO_ROOT_PASSWORD: 'password'
    volumes:
      - 'sail-minio:/data/minio'
    networks:
      - sail
    command: minio server /data/minio --console-address ":8900"
    healthcheck:
      test: &#91;"CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      retries: 3
      timeout: 5s

minio:

image: 'minio/minio:latest'

ports:

- '${FORWARD_MINIO_PORT:-9000}:9000'

- '${FORWARD_MINIO_CONSOLE_PORT:-8900}:8900'

environment:

MINIO_ROOT_USER: 'sail'

MINIO_ROOT_PASSWORD: 'password'

volumes:

- 'sail-minio:/data/minio'

networks:

- sail

command: minio server /data/minio --console-address ":8900"

healthcheck:

test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]

retries: 3

timeout: 5s

Programatically Creating a Minio Bucket

Here is where the magic happens. We need to import the image minio/mc

MinIO Client (mc) provides a modern alternative to UNIX commands like ls, cat, cp, mirror, diff, find etc. It supports filesystems and Amazon S3 compatible cloud storage service (AWS Signature v2 and v4).

The image can be found on DockerHub here : https://hub.docker.com/r/minio/mc/

This is essentially a command line tool for interacting with your Minio instance. In your docker-compose you need to add something like the following:

  minio-bucket:
    container_name: 'minio-bucket'
    image: minio/mc # import the minio mc 
    depends_on:
      - minio # ensure that minio is built before attempting to execute.
    environment:
      AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}
      AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}
      AWS_BUCKET: ${AWS_BUCKET}
      AWS_BUCKET_PRIVATE: ${AWS_BUCKET_PRIVATE}
      AWS_ENDPOINT: ${AWS_ENDPOINT}
    volumes:
      - './docker/minio:/etc/minio'
    networks:
      - sail
    entrypoint: /etc/minio/create.sh

minio-bucket:

container_name: 'minio-bucket'

image: minio/mc # import the minio mc

depends_on:

- minio # ensure that minio is built before attempting to execute.

environment:

AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}

AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}

AWS_BUCKET: ${AWS_BUCKET}

AWS_BUCKET_PRIVATE: ${AWS_BUCKET_PRIVATE}

AWS_ENDPOINT: ${AWS_ENDPOINT}

volumes:

- './docker/minio:/etc/minio'

networks:

- sail

entrypoint: /etc/minio/create.sh

Pay particular attention to the volumes and entry point. We are mounting a local directory ./docker/minio to /etc/minio in the container this directory contains a file create.sh which will be ran when this image is imported.

create.sh

#!/bin/sh
/usr/bin/mc config host add myminio ${AWS_ENDPOINT} ${AWS_ACCESS_KEY_ID} ${AWS_SECRET_ACCESS_KEY};
# /usr/bin/mc rm -r --force myminio/${AWS_BUCKET};
# /usr/bin/mc rm -r --force myminio/${AWS_BUCKET_PRIVATE};
/usr/bin/mc mb -p myminio/${AWS_BUCKET};
/usr/bin/mc policy set download myminio/${AWS_BUCKET};
exit 0;

#!/bin/sh

/usr/bin/mc config host add myminio ${AWS_ENDPOINT} ${AWS_ACCESS_KEY_ID} ${AWS_SECRET_ACCESS_KEY};

# /usr/bin/mc rm -r --force myminio/${AWS_BUCKET};

# /usr/bin/mc rm -r --force myminio/${AWS_BUCKET_PRIVATE};

/usr/bin/mc mb -p myminio/${AWS_BUCKET};

/usr/bin/mc policy set download myminio/${AWS_BUCKET};

exit 0;

This is the bare minimum required to create your first bucket with download access. Your bucket has now been programatically created by docker compose.

In a Laravel Sail environment you can now access the Minio Instance by hitting http://localhost:9000/login in your browser. If you navigate to your buckets you will see a new bucket created with the name provided by your ${AWS_BUCKET} variable

But for me this wasn’t enough, i needed to give fully public anonymous access to the bucket. In order to do this, you simply have to add the following lines to the create.sh file

/usr/bin/mc policy set public myminio/${AWS_BUCKET};
/usr/bin/mc anonymous set upload myminio/${AWS_BUCKET};
/usr/bin/mc anonymous set download myminio/${AWS_BUCKET};
/usr/bin/mc anonymous set public myminio/${AWS_BUCKET};
exit 0;

/usr/bin/mc policy set public myminio/${AWS_BUCKET};

/usr/bin/mc anonymous set upload myminio/${AWS_BUCKET};

/usr/bin/mc anonymous set download myminio/${AWS_BUCKET};

/usr/bin/mc anonymous set public myminio/${AWS_BUCKET};

exit 0;

Hopefully this will save someone out there some time.