---
title: Use MinIO for object storage
description: Use MinIO as the object store for your InfluxDB 3 Core instance. InfluxDB uses the MinIO S3-compatible API to interact with your MinIO server or cluster.
url: https://docs.influxdata.com/influxdb3/core/object-storage/minio/
estimated_tokens: 3205
product: InfluxDB 3 Core
version: core
publisher: InfluxData
canonical: https://docs.influxdata.com/influxdb3/core/object-storage/minio/
date: '2026-07-01T14:09:01-05:00'
lastmod: '2026-07-01T14:09:01-05:00'
---

Use [MinIO](https://min.io) as the Object store for your InfluxDB 3 Core instance.
InfluxDB uses the MinIO S3-compatible API to interact with your MinIO server or
cluster.

>
>
> MinIO is a high-performance, S3-compatible object storage solution released
> under the GNU AGPL v3.0 license. Designed for speed and scalability, it powers
> AI/ML, analytics, and data-intensive workloads with industry-leading performance.
>
>
>
> [MinIO GitHub repository](https://github.com/minio/minio?tab=readme-ov-file#readme)
>
>

MinIO provides both an open source version ([MinIO Community Edition](https://min.io/open-source/download))
and an enterprise version ([MinIO AIStor](https://min.io/download)).
While both can be used as your InfluxDB 3 Core object store,**this guide walks through using MinIO Community Edition**.

* [Object store requirements](#object-store-requirements)
* [Set up MinIO](#set-up-minio)
* [Configure InfluxDB to connect to MinIO](#configure-influxdb-to-connect-to-minio)
* [Confirm the object store is working](#confirm-the-object-store-is-working)

## Object store requirements

InfluxDB 3 Core uses the object store as the source of truth for catalog
state.
The catalog write path relies on conditional PUT (PUT-if-not-exists) to
serialize catalog log writes, and every node depends on immediate visibility
of writes made by any other node.
Your MinIO deployment must provide the object store semantics
InfluxDB 3 Core depends on.

### Consistency semantics

InfluxDB 3 Core requires at least the following from any S3-compatible object
store, including MinIO:

* **Strong read-after-write consistency**: a `GET` immediately after a
  successful `PUT` returns the new object.
* **Strong list-after-write consistency**: a `LIST` immediately after a
  successful `PUT` includes the new key.
* **Conditional PUT (PUT-if-not-exists) semantics**: concurrent creates of the
  same key serialize so that exactly one write succeeds and the other returns`AlreadyExists`.

A backend that violates these semantics can cause catalog split-brain, stale
reads on node startup, and unexpected node-state warnings.

> [!Note]
> Deploy MinIO on locally attached storage formatted with a POSIX-strong
> filesystem such as XFS.
> Avoid NFS-backed storage and topologies where multiple MinIO instances share
> the same backing volume—both can violate the consistency semantics
> InfluxDB 3 Core depends on.
> See MinIO’s[deployment guidance](https://min.io/docs/minio/linux/operations/installation.html)for details.

### Verify your object store

InfluxDB 3 Core 3.10.0 and later includes the[`influxdb3 debug object-store-check`](/influxdb3/core/reference/cli/influxdb3/debug/object-store-check/)command that validates an object store against the preceding semantic requirements.
Run it against your MinIO endpoint before putting the deployment into
production, and again after any change to the MinIO topology or backing
storage:

```bash
influxdb3 debug object-store-check \
  --object-store s3 \
  --bucket influxdb3 \
  --aws-endpoint http://localhost:9000 \
  --aws-access-key-id MINIO_USERNAME \
  --aws-secret-access-key MINIO_PASSWORD \
  --aws-allow-http \
  --check-prefix oscheck
```

The tool confines all writes to `<check-prefix>/oscheck-<uuid>/` and reports
any semantic violation it finds.
If the synthetic checks pass but a real catalog is still failing to load,
pass `--probe-prefix <your-catalog-prefix>` to replay the loader’s object
store operations against your real catalog in read-only mode.
See [`influxdb3 debug object-store-check`](/influxdb3/core/reference/cli/influxdb3/debug/object-store-check/)for the full flag reference.

## Set up MinIO

1. **Install and deploy a MinIO server or cluster**.

   You can install MinIO locally for testing and development or you can deploy
   a production MinIO cluster across multiple machines. The MinIO documentation
   provides detailed instructions for installing and deploying MinIO based on
   your target operating system:

   * [Install and deploy MinIO on **Linux**](https://min.io/docs/minio/linux/operations/installation.html)*(recommended for production deployments)*
   * [Install and deploy MinIO with **Kubernetes**](https://min.io/docs/minio/kubernetes/upstream/operations/installation.html)
   * [Install and deploy MinIO with **Docker**](https://min.io/docs/minio/container/operations/installation.html)
   * [Install and deploy MinIO on **macOS**](https://min.io/docs/minio/macos/operations/installation.html)
   * [Install and deploy MinIO on **Windows**](https://min.io/docs/minio/windows/operations/installation.html)

2. **Download and install the MinIO Client (`mc`)**.

   The MinIO client, or `mc` CLI, lets you perform administrative tasks on your
   MinIO server or cluster like creating users, assigning access policies, and
   more. Download and install the `mc` CLI for your local operating system
   and architecture.

   [See the **MinIO Client** section of the MinIO downloads page](https://min.io/open-source/download).

3. **Configure the `mc` CLI to connect to your MinIO server or cluster**.

   The `mc` CLI uses “aliases” to connect to a MinIO server or cluster.
   The alias refers to a set of connection credentials used to connect to and
   authorize with your MinIO server.

   Use the `mc alias set` command and provide the following:

   * **Alias**: A unique name or identifier for this credential set
     (`ALIAS`)
   * **MinIO URL**: The URL of your MinIO server or cluster
     (`https://localhost:9000`if running locally)
   * **Root username:** The root username you specified when setting up your
     MinIO server or cluster
     (`ROOT_USERNAME`)
   * **Root password**: The root password you specified when setting up your
     MinIO server or cluster
     (`ROOT_PASSWORD`)

   ```
   mc alias set ALIAS http://localhost:9000 ROOT_USERNAME ROOT_PASSWORD
   ```

4. **Create a MinIO bucket**.

   Use the *MinIO Console* or the *`mc mb` command* to create a new bucket
   in your MinIO server or cluster.

   #### MinIO Console ####

   The MinIO Console is a graphical user interface that lets you manage and browse
   buckets in your MinIO server or cluster. By default, the console is served on port`9001`.

   If running MinIO on your local machine, visit [http://localhost:9001](http://localhost:9001)to access the MinIO Console. If MinIO is running on a remote server, use your
   custom domain or IP to access the MinIO console.

   1. In the Minio Console, click **Create Bucket**.
   2. Enter a bucket name. For this guide, use `influxdb3`.
   3. Click **Create Bucket**.

   Use the `mc mb` command to create a new MinIO bucket named `influxdb3`.
   Provide the MinIO alias configured in [step 3](#configure-alias) and the bucket
   name using the `ALIAS/BUCKET_NAME` syntax–for example:

   ```
   mc mb ALIAS/influxdb3
   ```

5. **Create a MinIO user**.

   Use the `mc admin user add` command to create a new user.
   Provide the following:

   * **MinIO alias**: The MinIO server alias (created in [step 3](#configure-alias))
     to add the user to (`ALIAS`)
   * **Username**: A unique username for the user
     (`MINIO_USERNAME`)
   * **Password**: A password for the user
     (`MINIO_PASSWORD`)

   ```
   mc admin user add ALIAS MINIO_USERNAME MINIO_PASSWORD
   ```

   > [!Note]
> MinIO user credentials are equivalent to credentials you would typically
> use to authorize with AWS S3:
> * A MinIO username is equivalent to an AWS access key ID
> * A MinIO password is equivalent to an AWS secret key

   * A MinIO username is equivalent to an AWS access key ID
   * A MinIO password is equivalent to an AWS secret key

6. **Create an access policy that grants full access to the `influxdb3` bucket**.

   MinIO uses S3 compatible access policies to authorize access to buckets.
   To create a new access policy:

   1. Create a file named `influxdb3-policy.json` that contains the following
      JSON:

      ```
      {
        "Version": "2012-10-17",
        "Statement": [
          {
            "Action": [
              "s3:GetBucketLocation",
              "s3:ListBucket"
            ],
            "Effect": "Allow",
            "Resource": ["arn:aws:s3:::influxdb3"]
          },
          {
            "Action": [
              "s3:PutObject",
              "s3:GetObject",
              "s3:DeleteObject"
            ],
            "Effect": "Allow",
            "Resource": ["arn:aws:s3:::influxdb3/*"]
          }
        ]
      }
      ```

   2. Use the `mc admin policy create` command to create the new access policy
      in your MinIO server or cluster. Provide the following:

      * **MinIO alias**: The MinIO server alias (created in [step 3](#configure-alias)) to add
        the access policy to (`ALIAS`)
      * **Policy name**: A unique name for the policy
        (`POLICY_NAME`)
      * **Policy file**: The relative or absolute file path of your`influxdb3-policy.json` policy file
        (`/path/to/influxdb3-policy.json`)

      ```
      mc admin policy create \
        ALIAS \
        POLICY_NAME \
        /path/to/influxdb3-policy.json
      ```

7. **Attach the access policy to your user.**

   Use the `mc admin policy attach` command to attach the access policy to your
   user.

   > [!Note]
> MinIO supports attaching access policies to both users and user groups.
> All users in a user group inherit policies attached to the group.
> For information about managing MinIO user groups, see[MinIO Group Management](https://min.io/docs/minio/linux/administration/identity-access-management/minio-group-management.html).

   Provide the following:

   * **MinIO alias**: The MinIO server alias created in [step 3](#configure-alias)(`ALIAS`)
   * **Policy name**: A unique username for the user
     (`POLICY_NAME`)
   * **Username** or **group name**: The user or user group to assign the policy to
     (`MINIO_USERNAME` or`MINIO_GROUP_NAME`)

   #### user ####

   ```
   mc admin policy attach ALIAS POLICY_NAME --user MINIO_USERNAME
   ```

   ```
   mc admin policy attach ALIAS POLICY_NAME --group MINIO_GROUP_NAME
   ```

Your MinIO server or cluster is now set up and ready to be used with InfluxDB 3 Core.

## Configure InfluxDB to connect to MinIO

To use your MinIO server or cluster as the object store for your InfluxDB 3 Core
instance, provide the following options or environment variables with the`influxdb3 serve` command:

#### Command options ####

* `--node-id`: Your InfluxDB 3 Core node ID (`INFLUXDB_NODE_ID`)
* `--object-store`: `s3`
* `--bucket`: `influxdb3`
* `--aws-endpoint`: Your MinIO URL (`http://localhost:9000` if running locally)
* `--aws-access-key-id`: Your MinIO username (`MINIO_USERNAME`)
* `--aws-secret-access-key`: Your MinIO password (`MINIO_PASSWORD`)
* `--aws-allow-http`: *(Optional)* Include if *not* using HTTPS to connect to
  your MinIO server or cluster

```
influxdb3 serve \

--node-id INFLUXDB_NODE_ID \
  --object-store s3 \
  --bucket influxdb3 \
  --aws-endpoint http://localhost:9000 \
  --aws-access-key-id MINIO_USERNAME \
  --aws-secret-access-key MINIO_PASSWORD \
  --aws-allow-http
```

* `INFLUXDB3_NODE_IDENTIFIER_PREFIX`: Your InfluxDB 3 Core node ID (`INFLUXDB_NODE_ID`)
* `INFLUXDB3_OBJECT_STORE`: `s3`
* `INFLUXDB3_BUCKET`: `influxdb3`
* `AWS_ENDPOINT`: Your MinIO URL (`http://localhost:9000` if running locally)
* `AWS_ACCESS_KEY_ID`: Your MinIO username (`MINIO_USERNAME`)
* `AWS_SECRET_ACCESS_KEY`: Your MinIO password (`MINIO_PASSWORD`)
* `AWS_ALLOW_HTTP`: *(Optional)* Set to `true` if *not* using HTTPS to connect to
  your MinIO server or cluster (default is `false`)

```

export INFLUXDB3_NODE_IDENTIFIER_PREFIX=INFLUXDB_NODE_ID
export INFLUXDB3_OBJECT_STORE=s3
export INFLUXDB3_BUCKET=influxdb3
export AWS_ENDPOINT=http://localhost:9000
export AWS_ACCESS_KEY_ID=MINIO_USERNAME
export AWS_SECRET_ACCESS_KEY=MINIO_PASSWORD
export AWS_ALLOW_HTTP=true

influxdb3 serve
```

## Confirm the object store is working

When InfluxDB 3 Core starts, it will seed your MinIO object store with the
necessary directory structure and begin storing data there. Confirm the object
store is functioning properly:

1. View the `influxdb3 serve` log output to confirm that the server is running correctly.

2. Inspect the contents of your MinIO `influxdb3` bucket to confirm that the
   necessary directory structure is created. You can use the **MinIO Console**or the **`mc ls` command** to view the contents of a bucket–for example:

   ```
   mc ls ALIAS/influxdb3
   ```

#### Related

* [Install and Deploy MinIO](https://min.io/docs/minio/linux/operations/installation.html)
* [InfluxDB 3 Core configuration options](/influxdb3/core/reference/config-options/)

[object storage](/influxdb3/core/tags/object-storage/)[S3](/influxdb3/core/tags/s3/)