public_git/bitnami-containers
1
0
Fork 0
mirror of https://github.com/bitnami/containers.git synced 2026-10-18 00:47:20 +02:00
Code Issues Projects Releases Wiki Activity

[bitnami/minio] Release 2025.10.15-debian-12-r10 (#91363)

Browse Source 
Signed-off-by: Bitnami Bot <bitnami.bot@broadcom.com>
This commit is contained in:
Bitnami Bot
2026-03-06 16:31:13 +01:00
committed by GitHub
parent 12ecdf9862
commit 2c695a1d70
2 changed files with 18 additions and 349 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bitnami/minio/2025/debian-12/Dockerfile
+4 -4
View File
@@ -7,7 +7,7 @@ ARG DOWNLOADS_URL="downloads.bitnami.com/files/stacksmith"
ARG TARGETARCH
LABEL org.opencontainers.image.base.name="docker.io/bitnami/minideb:bookworm" \
org.opencontainers.image.created="2026-02-19T03:06:00Z" \
org.opencontainers.image.created="2026-03-06T15:06:30Z" \
org.opencontainers.image.description="Application packaged by Broadcom, Inc." \
org.opencontainers.image.documentation="https://github.com/bitnami/containers/tree/main/bitnami/minio/README.md" \
org.opencontainers.image.source="https://github.com/bitnami/containers/tree/main/bitnami/minio" \
@@ -28,8 +28,8 @@ RUN --mount=type=secret,id=downloads_url,env=SECRET_DOWNLOADS_URL \
DOWNLOADS_URL=${SECRET_DOWNLOADS_URL:-${DOWNLOADS_URL}} ; \
mkdir -p /tmp/bitnami/pkg/cache/ ; cd /tmp/bitnami/pkg/cache/ || exit 1 ; \
COMPONENTS=( \
"minio-client-2025.8.13-7-linux-${OS_ARCH}-debian-12" \
"minio-2025.10.15-5-linux-${OS_ARCH}-debian-12" \
"minio-client-2025.8.13-8-linux-${OS_ARCH}-debian-12" \
"minio-2025.10.15-6-linux-${OS_ARCH}-debian-12" \
) ; \
for COMPONENT in "${COMPONENTS[@]}"; do \
if [ ! -f "${COMPONENT}.tar.gz" ]; then \
@@ -50,7 +50,7 @@ RUN /opt/bitnami/scripts/minio-client/postunpack.sh
RUN /opt/bitnami/scripts/minio/postunpack.sh
ENV APP_VERSION="2025.10.15" \
BITNAMI_APP_NAME="minio" \
IMAGE_REVISION="9" \
IMAGE_REVISION="10" \
PATH="/opt/bitnami/minio-client/bin:/opt/bitnami/minio/bin:$PATH"
VOLUME [ "/bitnami/minio/data", "/certs" ]
bitnami/minio/README.md
+14 -345
View File
@@ -1,7 +1,5 @@
# Bitnami Object Storage based on MinIO&reg;
## What is Bitnami Object Storage based on MinIO&reg;?
> MinIO&reg; is an object storage server, compatible with Amazon S3 cloud storage service, mainly used for storing unstructured data (such as photos, videos, log files, etc.).
[Overview of Bitnami Object Storage based on MinIO&reg;](https://min.io/)
@@ -64,57 +62,17 @@ cd bitnami/APP/VERSION/OPERATING-SYSTEM
docker build -t bitnami/APP:latest .
```
## Using `docker-compose.yaml`
Please be aware this file has not undergone internal testing. Consequently, we advise its use exclusively for development or testing purposes. For production-ready deployments, we highly recommend utilizing its associated [Bitnami Helm chart](https://github.com/bitnami/charts/tree/main/bitnami/minio).
## Persisting your database
If you remove the container all your data will be lost, and the next time you run the image the database will be reinitialized. To avoid this loss of data, you should mount a volume that will persist even after the container is removed.
For persistence you should mount a directory at the `/bitnami/minio/data` path.
For persistence you should mount a directory at the `/bitnami/minio/data` path. You can also mount a volume to a custom path inside the container, provided that you run the container using the `MINIO_DATA_DIR` environment variable.
```console
docker run --name minio \
--publish 9000:9000 \
--publish 9001:9001 \
--volume /path/to/minio-persistence:/bitnami/minio/data \
bitnami/minio:latest
```
or by modifying the [`docker-compose.yml`](https://github.com/bitnami/containers/blob/main/bitnami/minio/docker-compose.yml) file present in this repository:
```yaml
services:
minio:
...
volumes:
- /path/to/minio-persistence:/bitnami/minio/data
...
```
You can also mount a volume to a custom path inside the container, provided that you run the container using the `MINIO_DATA_DIR` environment variable.
```console
docker run --name minio \
--publish 9000:9000 \
--publish 9001:9001 \
--volume /path/to/minio-persistence:/custom/path/within/container \
--env MINIO_DATA_DIR=/custom/path/within/container \
bitnami/minio:latest
```
or by modifying the [`docker-compose.yml`](https://github.com/bitnami/containers/blob/main/bitnami/minio/docker-compose.yml) file present in this repository:
```yaml
services:
minio:
...
volumes:
- /path/to/minio-persistence:/custom/path/within/container
...
environment:
- MINIO_DATA_DIR=/custom/path/within/container
...
```
> NOTE: As this is a non-root container, the mounted files and directories must have the proper permissions for the UID `1001`.
> **NOTE** As this is a non-root container, the mounted files and directories must have the proper permissions for the UID `1001`.
## Connecting to other containers
@@ -122,89 +80,14 @@ Using [Docker container networking](https://docs.docker.com/engine/userguide/net
Containers attached to the same network can communicate with each other using the container name as the hostname.
### Using the Command Line
In this example, we will create a [MinIO(R) client](https://github.com/bitnami/containers/blob/main/bitnami/minio-client) container that will connect to the server container that is running on the same docker network as the client.
#### Step 1: Create a network
```console
docker network create app-tier --driver bridge
```
#### Step 2: Launch the MinIO(R) server container
Use the `--network app-tier` argument to the `docker run` command to attach the MinIO(R) container to the `app-tier` network.
```console
docker run -d --name minio-server \
--env MINIO_ROOT_USER="minio-root-user" \
--env MINIO_ROOT_PASSWORD="minio-root-password" \
--network app-tier \
bitnami/minio:latest
```
#### Step 3: Launch your MinIO(R) Client container
Finally we create a new container instance to launch the MinIO(R) client and connect to the server created in the previous step. In this example, we create a new bucket in the MinIO(R) storage server:
```console
docker run -it --rm --name minio-client \
--env MINIO_SERVER_HOST="minio-server" \
--env MINIO_SERVER_ACCESS_KEY="minio-access-key" \
--env MINIO_SERVER_SECRET_KEY="minio-secret-key" \
--network app-tier \
bitnami/minio-client \
mb minio/my-bucket
```
### Using a Docker Compose file
When not specified, Docker Compose automatically sets up a new network and attaches all deployed services to that network. However, we will explicitly define a new `bridge` network named `app-tier`. In this example we assume that you want to connect to the MinIO(R) server from your own custom application image which is identified in the following snippet by the service name `myapp`.
```yaml
version: '2'
networks:
app-tier:
driver: bridge
services:
minio:
image: bitnami/minio:latest
ports:
- 9000:9000
- 9001:9001
environment:
- MINIO_ROOT_USER=minio-root-user
- MINIO_ROOT_PASSWORD=minio-root-password
networks:
- app-tier
myapp:
image: YOUR_APPLICATION_IMAGE
networks:
- app-tier
environment:
- MINIO_SERVER_ACCESS_KEY=minio-access-key
- MINIO_SERVER_SECRET_KEY=minio-secret-key
```
> **IMPORTANT**:
>
> 1. Please update the **YOUR_APPLICATION_IMAGE_** placeholder in the above snippet with your application image
> 2. In your application container, use the hostname `minio` to connect to the MinIO(R) server. Use the environment variables `MINIO_SERVER_ACCESS_KEY` and `MINIO_SERVER_SECRET_KEY` to configure the credentials to access the MinIO(R) server.
> 3. Make sure that the environment variables `MINIO_ROOT_PASSWORD` and `MINIO_SERVER_SECRET_KEY` meet the 8 character minimum length requirement enforced by MinIO(R).
Launch the containers using:
```console
docker-compose up -d
```
## Configuration
The following section describes the supported environment variables
### Environment variables
The following tables list the main variables you can set.
#### Customizable environment variables
| Name | Description | Default Value |
@@ -261,56 +144,13 @@ docker-compose exec minio mc admin info local
### Creating default buckets
You can create a series of buckets in the MinIO(R) server during the initialization of the container by setting the environment variable `MINIO_DEFAULT_BUCKETS` as shown below (policy is optional):
```console
docker run --name minio \
--publish 9000:9000 \
--publish 9001:9001 \
--env MINIO_DEFAULT_BUCKETS='my-first-bucket:policy,my-second-bucket' \
bitnami/minio:latest
```
or by modifying the [`docker-compose.yml`](https://github.com/bitnami/containers/blob/main/bitnami/minio/docker-compose.yml) file present in this repository:
```yaml
services:
minio:
...
environment:
- MINIO_DEFAULT_BUCKETS=my-first-bucket:policy,my-second-bucket
...
```
You can create a series of buckets in the MinIO(R) server during the initialization of the container by setting the environment variable `MINIO_DEFAULT_BUCKETS`.
### Securing access to MinIO(R) server with TLS
You can secure the access to MinIO(R) server with TLS as detailed at [MinIO(R) documentation](https://docs.min.io/docs/how-to-secure-access-to-minio-server-with-tls.html).
This image expects the variable `MINIO_SCHEME` set to `https` and certificates to be mounted at the `/certs` directory. You can put your key and certificate files on a local directory and mount it in the container as shown below:
```console
docker run --name minio \
--publish 9000:9000 \
--publish 9001:9001 \
--volume /path/to/certs:/certs \
--env MINIO_SCHEME=https
bitnami/minio:latest
```
or by modifying the [`docker-compose.yml`](https://github.com/bitnami/containers/blob/main/bitnami/minio/docker-compose.yml) file present in this repository:
```yaml
services:
minio:
...
environment:
...
- MINIO_SCHEME=https
...
volumes:
- /path/to/certs:/certs
...
```
This image expects the variable `MINIO_SCHEME` set to `https` and certificates to be mounted at the `/certs` directory. You can put your key and certificate files on a local directory and mount it in the container.
### Setting up MinIO(R) in Distributed Mode
@@ -321,81 +161,7 @@ You can configure MinIO(R) in Distributed Mode to setup a highly-available stora
- `MINIO_ROOT_USER`: MinIO(R) server root user. Must be common on every node.
- `MINIO_ROOT_PASSWORD`: MinIO(R) server root password. Must be common on every node.
You can use the Docker Compose below to create an 4-node distributed MinIO(R) setup:
```yaml
version: '2'
services:
minio1:
image: bitnami/minio:latest
environment:
- MINIO_ROOT_USER=minio-root-user
- MINIO_ROOT_PASSWORD=minio-root-password
- MINIO_DISTRIBUTED_MODE_ENABLED=yes
- MINIO_DISTRIBUTED_NODES=minio1,minio2,minio3,minio4
- MINIO_SKIP_CLIENT=yes
minio2:
image: bitnami/minio:latest
environment:
- MINIO_ROOT_USER=minio-root-user
- MINIO_ROOT_PASSWORD=minio-root-password
- MINIO_DISTRIBUTED_MODE_ENABLED=yes
- MINIO_DISTRIBUTED_NODES=minio1,minio2,minio3,minio4
- MINIO_SKIP_CLIENT=yes
minio3:
image: bitnami/minio:latest
environment:
- MINIO_ROOT_USER=minio-root-user
- MINIO_ROOT_PASSWORD=minio-root-password
- MINIO_DISTRIBUTED_MODE_ENABLED=yes
- MINIO_DISTRIBUTED_NODES=minio1,minio2,minio3,minio4
- MINIO_SKIP_CLIENT=yes
minio4:
image: bitnami/minio:latest
environment:
- MINIO_ROOT_USER=minio-root-user
- MINIO_ROOT_PASSWORD=minio-root-password
- MINIO_DISTRIBUTED_MODE_ENABLED=yes
- MINIO_DISTRIBUTED_NODES=minio1,minio2,minio3,minio4
- MINIO_SKIP_CLIENT=yes
```
MinIO(R) also supports ellipsis syntax (`{1..n}`) to list the MinIO(R) node hosts, where `n` is the number of nodes. This syntax is also valid to use multiple drives (`{1..m}`) on each MinIO(R) node, where `n` is the number of drives per node. You can use the Docker Compose below to create an 2-node distributed MinIO(R) setup with 2 drives per node:
```yaml
version: '2'
services:
minio-0:
image: bitnami/minio:latest
volumes:
- minio_0_data_0:/bitnami/minio/data-0
- minio_0_data_1:/bitnami/minio/data-1
environment:
- MINIO_ROOT_USER=minio
- MINIO_ROOT_PASSWORD=miniosecret
- MINIO_DISTRIBUTED_MODE_ENABLED=yes
- MINIO_DISTRIBUTED_NODES=minio-{0...1}/bitnami/minio/data-{0...1}
minio-1:
image: bitnami/minio:latest
volumes:
- minio_1_data_0:/bitnami/minio/data-0
- minio_1_data_1:/bitnami/minio/data-1
environment:
- MINIO_ROOT_USER=minio
- MINIO_ROOT_PASSWORD=miniosecret
- MINIO_DISTRIBUTED_MODE_ENABLED=yes
- MINIO_DISTRIBUTED_NODES=minio-{0...1}/bitnami/minio/data-{0...1}
volumes:
minio_0_data_0:
driver: local
minio_0_data_1:
driver: local
minio_1_data_0:
driver: local
minio_1_data_1:
driver: local
```
MinIO(R) also supports ellipsis syntax (`{1..n}`) to list the MinIO(R) node hosts, where `n` is the number of nodes. This syntax is also valid to use multiple drives (`{1..m}`) on each MinIO(R) node, where `n` is the number of drives per node.
Find more information about the Distributed Mode in the [MinIO(R) documentation](https://docs.min.io/docs/distributed-minio-quickstart-guide.html).
@@ -403,18 +169,7 @@ Find more information about the Distributed Mode in the [MinIO(R) documentation]
MinIO(R) configures the access & secret key during the 1st initialization based on the `MINIO_ROOT_USER` and `MINIO_ROOT_PASSWORD` environment variables, respetively.
When using persistence, MinIO(R) will reuse the data configured during the 1st initialization by default, ignoring whatever values are set on these environment variables. You can force MinIO(R) to reconfigure the keys based on the environment variables by setting the `MINIO_FORCE_NEW_KEYS` environment variable to `yes`:
```console
docker run --name minio \
--publish 9000:9000 \
--publish 9001:9001 \
--env MINIO_FORCE_NEW_KEYS="yes" \
--env MINIO_ROOT_USER="new-minio-root-user" \
--env MINIO_ROOT_PASSWORD="new-minio-root-password" \
--volume /path/to/minio-persistence:/bitnami/minio/data \
bitnami/minio:latest
```
When using persistence, MinIO(R) will reuse the data configured during the 1st initialization by default, ignoring whatever values are set on these environment variables. You can force MinIO(R) to reconfigure the keys based on the environment variables by setting the `MINIO_FORCE_NEW_KEYS` environment variable to `yes`.
### FIPS configuration in Bitnami Secure Images
@@ -444,92 +199,6 @@ To enable HTTP log trace, you can set the environment variable `MINIO_HTTP_TRACE
When setting this environment variable to `/opt/bitnami/minio/log/minio.log`, the logs will be sent to the `stdout`.
```console
docker run --name minio \
--publish 9000:9000 \
--publish 9001:9001 \
--env MINIO_HTTP_TRACE=/opt/bitnami/minio/log/minio.log \
bitnami/minio:latest
```
or by modifying the [`docker-compose.yml`](https://github.com/bitnami/containers/blob/main/bitnami/minio/docker-compose.yml) file present in this repository:
```yaml
services:
minio:
...
environment:
- MINIO_HTTP_TRACE=/opt/bitnami/minio/log/minio.log
...
```
## Maintenance
### Upgrade this image
Bitnami provides up-to-date versions of MinIO(R), including security patches, soon after they are made upstream. We recommend that you follow these steps to upgrade your container.
#### Step 1: Get the updated image
```console
docker pull bitnami/minio:latest
```
or if you're using Docker Compose, update the value of the image property to
`bitnami/minio:latest`.
#### Step 2: Stop and backup the currently running container
Stop the currently running container using the command
```console
docker stop minio
```
or using Docker Compose:
```console
docker-compose stop minio
```
Next, take a snapshot of the persistent volume `/path/to/minio-persistence` using:
```console
rsync -a /path/to/minio-persistence /path/to/minio-persistence.bkp.$(date +%Y%m%d-%H.%M.%S)
```
#### Step 3: Remove the currently running container
```console
docker rm -v minio
```
or using Docker Compose:
```console
docker-compose rm -v minio
```
#### Step 4: Run the new image
Re-create your container from the new image.
```console
docker run --name minio bitnami/minio:latest
```
or using Docker Compose:
```console
docker-compose up minio
```
## Using `docker-compose.yaml`
Please be aware this file has not undergone internal testing. Consequently, we advise its use exclusively for development or testing purposes. For production-ready deployments, we highly recommend utilizing its associated [Bitnami Helm chart](https://github.com/bitnami/charts/tree/main/bitnami/minio).
If you detect any issue in the `docker-compose.yaml` file, feel free to report it or contribute with a fix by following our [Contributing Guidelines](https://github.com/bitnami/containers/blob/main/CONTRIBUTING.md).
## License
Copyright &copy; 2026 Broadcom. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.