Skip to content

⭐️⭐️⭐️ Open-source, self-hosted alternative to Linear and Plane. Project management and issue tracking where teams and AI agents work side by side to plan and ship products.

feat: replace MinIO with RustFS for attachment storage (#437)

Croffe063a152857e
diff --git a/.env.example b/.env.example
index ece1bb1c..2a8f39af 100644
--- a/.env.example
+++ b/.env.example
@@ -51,16 +51,16 @@ API_PORT=3000
# Upgrade without a dump — for an operator who backs up by other means.
# SKIP_PRE_MIGRATION_BACKUP=1
-# ── S3 object store: MinIO (issue attachments; metadata stays in the DB) ──
-# Leave S3_* unset to disable uploads. The keys double as MinIO root credentials;
+# ── S3 object store: RustFS (issue attachments; metadata stays in the DB) ──
+# Leave S3_* unset to disable uploads. The keys double as RustFS root credentials;
# the secret must be >= 8 chars. Upload limits are DB settings (god mode), not env.
S3_ENDPOINT=http://localhost:9000 # inside compose: http://minio:9000
S3_BUCKET=planner-attachments
S3_ACCESS_KEY_ID=minioadmin
S3_SECRET_ACCESS_KEY=minioadmin
-S3_REGION=us-east-1 # required by the SDK, ignored by MinIO
+S3_REGION=us-east-1 # required by the SDK, ignored by RustFS
# Set to false for a hosted store that serves only virtual-host-style buckets
-# (Railway buckets, Cloudflare R2). MinIO needs the default.
+# (Railway buckets, Cloudflare R2). RustFS needs the default.
# S3_FORCE_PATH_STYLE=false
# ── Secret encryption (AI provider API keys at rest) ──
diff --git a/.env.test.example b/.env.test.example
index 3b2e0d87..bd2c2dfa 100644
--- a/.env.test.example
+++ b/.env.test.example
@@ -23,8 +23,8 @@ APP_URL=http://localhost:3001
# NODE_ENV gates the db reset helper (belt-and-suspenders with the db-name check).
NODE_ENV=test
-# S3-compatible object store (MinIO) for the attachments feature test. The local
-# dev MinIO from docker-compose.dev.yml serves this; its minio-init creates the
+# S3-compatible object store (RustFS) for the attachments feature test. The local
+# dev RustFS from docker-compose.dev.yml serves this; its minio-init creates the
# bucket. Reuse the same values as root .env — the test only writes uuid-keyed
# objects and deletes what it creates.
S3_ENDPOINT=http://localhost:9000
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1b5118ef..46185bbc 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -81,16 +81,16 @@ jobs:
- uses: actions/checkout@v7
# Integration tests need a live database, so they run in the compose gate:
- # a throwaway Postgres and MinIO, with the api built from the production
+ # a throwaway Postgres and RustFS, with the api built from the production
# Dockerfile. Building both api-test and worker-test also verifies their
# Dockerfiles build.
- name: Build test images
run: docker compose -f docker-compose.test.yml build
- # `run` starts api-test's dependencies (Postgres healthy, the MinIO bucket
+ # `run` starts api-test's dependencies (Postgres healthy, the RustFS bucket
# init completed), runs the suite, and exits with its code. It does not use
# --abort-on-container-exit, which would tear the stack down the moment the
- # one-shot minio-test-init exits, before api-test starts.
+ # one-shot rustfs-test-init exits, before api-test starts.
- name: Run the compose test gate
run: docker compose -f docker-compose.test.yml run --rm api-test
diff --git a/AGENTS.md b/AGENTS.md
index 18c78cd5..dac31d35 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -126,7 +126,7 @@ are the part to preserve when changing the script:
- Try it and Develop restart what is already up rather than setting up beside it, and each
offers to stop the other: they read the same `.env`, so they publish the same api and web
- ports. Develop also offers to stop the PR stack, whose MinIO ports are fixed in its own
+ ports. Develop also offers to stop the PR stack, whose RustFS ports are fixed in its own
compose file. A refusal ends the run and changes nothing.
- A busy port is offered for change, never forced. The check connects rather than binds, to
`127.0.0.1` and `::1`: on macOS a bind on one loopback address succeeds beside a listener
@@ -164,7 +164,7 @@ are the part to preserve when changing the script:
| File | Purpose |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `docker-compose.dev.yml` | local backing services only: Postgres + MinIO. The apps run on the host. |
+| `docker-compose.dev.yml` | local backing services only: Postgres + RustFS. The apps run on the host. |
| `docker-compose.yml` | self-hosting stack. Runs the published images (`docker compose pull && up -d`) or builds them from source (`up -d --build`); reads a plain `.env`, requires the secrets via `${VAR:?}`. |
| `docker-compose.coolify.yml` | the same stack for Coolify: reads its generated `SERVICE_*` variables and builds from source. No `image:` here — with both fields Coolify still builds, and stops creating rollback images. |
| `docker-compose.coolify-images.yml` | the same stack as a Coolify service (New Resource → Docker Compose Empty): the published images, no `build:`, no `ports:`, and the two domains declared with `SERVICE_URL_API_3000` / `SERVICE_URL_WEB_3001`. |
@@ -188,10 +188,10 @@ docker compose -f docker-compose.test.yml build
docker compose -f docker-compose.test.yml run --rm api-test
```
-`run` starts api-test's dependencies (Postgres healthy, the MinIO bucket init
+`run` starts api-test's dependencies (Postgres healthy, the RustFS bucket init
completed), runs the suite, and exits with its code. It does not use
`--abort-on-container-exit`, which tears the stack down the moment the one-shot
-`minio-test-init` exits, before api-test starts.
+`rustfs-test-init` exits, before api-test starts.
The test database is created by the `postgres-test` service (`POSTGRES_DB=itsaplan_test`,
tmpfs — nothing persists). The `test` job in `.github/workflows/ci.yml` runs these
diff --git a/README.md b/README.md
index 6982adef..2b36f445 100644
--- a/README.md
+++ b/README.md
@@ -168,7 +168,7 @@ needed. Run it again later to restart the instance; the data stays.
| UI | [shadcn/ui](https://ui.shadcn.com/) + Tailwind v4 |
| Auth | [better-auth](https://better-auth.com/) |
| Database | [Drizzle](https://orm.drizzle.team/) + PostgreSQL |
-| Storage | S3-compatible object store (MinIO) |
+| Storage | S3-compatible object store (RustFS) |
| AI agents | [Mastra](https://github.com/mastra-ai/mastra) |
## Contributing
diff --git a/SECURITY.md b/SECURITY.md
index ff95bb03..c05c5c44 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -44,5 +44,5 @@ An instance is only as safe as its configuration:
- `APP_ENCRYPTION_KEY` encrypts stored provider credentials at rest. Losing it makes
those credentials undecryptable, changing it has the same effect.
- Serve the app over HTTPS. Cookies are marked `secure` in production.
-- Keep the MinIO console and the Postgres port off the public network.
+- Keep the RustFS console and the Postgres port off the public network.
- `APP_URL` must be the real frontend origin, and nothing else (it is the auth trusted origin).
diff --git a/apps/api/AGENTS.md b/apps/api/AGENTS.md
index fc04282c..107d3a31 100644
--- a/apps/api/AGENTS.md
+++ b/apps/api/AGENTS.md
@@ -248,8 +248,8 @@ bun run test # from apps/api, or at root via turbo
```
The `test` script loads `--env-file=../../.env.test`. The attachments test also needs
-MinIO + `S3_*` in `.env.test` (`docker compose -f docker-compose.dev.yml up -d` creates
-the bucket); the Docker test gate starts its own throwaway MinIO.
+RustFS + `S3_*` in `.env.test` (`docker compose -f docker-compose.dev.yml up -d` creates
+the bucket); the Docker test gate starts its own throwaway RustFS.
**Layout.** Tests colocated under `__tests__/`, `integration/` (Treaty vs running app +
test DB, one file per feature) or `unit/` (pure functions, no session/HTTP/DB — import
diff --git a/apps/api/src/modules/agents/skills/__tests__/integration/agent-skills.test.ts b/apps/api/src/modules/agents/skills/__tests__/integration/agent-skills.test.ts
index 52151656..dca4eb0b 100644
--- a/apps/api/src/modules/agents/skills/__tests__/integration/agent-skills.test.ts
+++ b/apps/api/src/modules/agents/skills/__tests__/integration/agent-skills.test.ts
@@ -10,7 +10,7 @@ import { createAgent } from '#tests/helpers/agents';
// The team skill library: SKILL.md documents (plus optional reference files) given to
// the internal agents of every project the team owns. Content lives in the object
// store; the row holds metadata. Access is the agent_skills permission resource,
-// resolved on the team. These tests need the object store (MinIO), like the
+// resolved on the team. These tests need the object store (RustFS), like the
// attachments test.
async function setup() {
diff --git a/apps/api/src/modules/attachments/__tests__/integration/attachments.test.ts b/apps/api/src/modules/attachments/__tests__/integration/attachments.test.ts
index c01b395f..4806476a 100644
--- a/apps/api/src/modules/attachments/__tests__/integration/attachments.test.ts
+++ b/apps/api/src/modules/attachments/__tests__/integration/attachments.test.ts
@@ -5,7 +5,7 @@ import { resetDb } from '#tests/helpers/db';
import { clearLimits, setLimits } from '#tests/helpers/limits';
// Attachments feature: metadata in Postgres, bytes in the object store (shared/
-// s3.ts against a real MinIO — see the Tests setup for S3_* env). This is the
+// s3.ts against a real RustFS — see the Tests setup for S3_* env). This is the
// only test that exercises s3.ts (putObject/getObject/deleteObject) and the one
// public, unauthenticated route (GET /attachments/:publicId/raw), which is the
// auth-context session-gate exception.
diff --git a/apps/api/src/modules/chat-attachments/__tests__/integration/chat-attachments.test.ts b/apps/api/src/modules/chat-attachments/__tests__/integration/chat-attachments.test.ts
index e1df8aa4..c9171b5a 100644
--- a/apps/api/src/modules/chat-attachments/__tests__/integration/chat-attachments.test.ts
+++ b/apps/api/src/modules/chat-attachments/__tests__/integration/chat-attachments.test.ts
@@ -6,7 +6,7 @@ import { resetDb } from '#tests/helpers/db';
// Chat attachments: the upload and read routes behind the upload_chat_attachment
// and read_chat_attachment MCP tools, and the public download route the chat
-// message links to. Needs MinIO like the attachments suite.
+// message links to. Needs RustFS like the attachments suite.
async function setup() {
const owner = await signUpTestUser();
diff --git a/apps/api/src/modules/imports/__tests__/integration/imports.test.ts b/apps/api/src/modules/imports/__tests__/integration/imports.test.ts
index 60eacf07..1a048aaa 100644
--- a/apps/api/src/modules/imports/__tests__/integration/imports.test.ts
+++ b/apps/api/src/modules/imports/__tests__/integration/imports.test.ts
@@ -9,7 +9,7 @@ import { createMappedImport } from '../../service';
// The import flow: the file is uploaded through the chat-attachments route, an
// agent turns it into a draft by saving a column mapping (the
// prepare_issue_import tool calls createMappedImport in process), and the confirm
-// route creates the issues. Needs MinIO like the attachments suite.
+// route creates the issues. Needs RustFS like the attachments suite.
async function setup() {
const owner = await signUpTestUser();
diff --git a/apps/api/src/modules/initiatives/__tests__/integration/initiative-attachments.test.ts b/apps/api/src/modules/initiatives/__tests__/integration/initiative-attachments.test.ts
index c102a563..4ba9ba12 100644
--- a/apps/api/src/modules/initiatives/__tests__/integration/initiative-attachments.test.ts
+++ b/apps/api/src/modules/initiatives/__tests__/integration/initiative-attachments.test.ts
@@ -5,7 +5,7 @@ import { resetDb } from '#tests/helpers/db';
import { clearLimits, setLimits } from '#tests/helpers/limits';
// Initiative attachments: metadata in Postgres, bytes in the object store (real
-// MinIO — see the api Tests setup for S3_*). The raw route is public, like the
+// RustFS — see the api Tests setup for S3_*). The raw route is public, like the
// issue one, so an attachment can be embedded in the description.
async function setupInitiative() {
diff --git a/apps/web/src/features/account/services/profile.service.ts b/apps/web/src/features/account/services/profile.service.ts
index 1254e389..8fac8ffc 100644
--- a/apps/web/src/features/account/services/profile.service.ts
+++ b/apps/web/src/features/account/services/profile.service.ts
@@ -1,6 +1,6 @@
import { API_URL, apiFailure } from '@/lib/api/core/client';
-// Uploads an avatar image to the API (stored in MinIO). The API writes the new URL
+// Uploads an avatar image to the API (stored in the S3 object store). The API writes the new URL
// to the user's image column itself and returns it, so the caller only has to read
// the session again. Multipart, so the browser sets the boundary itself — no
// Content-Type header.
diff --git a/charts/itsaplan/README.md b/charts/itsaplan/README.md
index a899a641..26973e4c 100644
--- a/charts/itsaplan/README.md
+++ b/charts/itsaplan/README.md
@@ -22,7 +22,7 @@ helm install itsaplan charts/itsaplan \
--set secrets.s3SecretAccessKey=minioadmin
```
-This deploys the full stack with the built-in PostgreSQL and MinIO. For production, use a values file instead of `--set`
+This deploys the full stack with the built-in PostgreSQL and RustFS. For production, use a values file instead of `--set`
flags and store secrets externally (Sealed Secrets, External Secrets Operator, etc.).
## What gets deployed
@@ -34,8 +34,8 @@ flags and store secrets externally (Sealed Secrets, External Secrets Operator, e
| Worker | Deployment | always |
| Bot (Telegram) | Deployment | `bot.enabled` (default `true`) |
| PostgreSQL | StatefulSet + Service + PVC | `postgresql.enabled` (default `true`) |
-| MinIO | Deployment + Service + PVC | `minio.enabled` (default `true`) |
-| MinIO bucket init | Job (Helm hook) | `minio.enabled` |
+| RustFS | Deployment + Service + PVC | `minio.enabled` (default `true`) |
+| RustFS bucket init | Job (Helm hook) | `minio.enabled` |
| Web Ingress | Ingress | `ingress.enabled` |
| API Ingress | Ingress or IngressRoute | `ingress.enabled` + `ingress.api.mode` |
| TLS Certificate | Certificate (cert-manager) | `certificate.enabled` |
@@ -55,7 +55,7 @@ externalDatabase:
## Using an external S3-compatible store
-Disable the built-in MinIO and provide an endpoint:
+Disable the built-in RustFS and provide an endpoint:
```yaml
minio:
@@ -68,7 +68,7 @@ api:
env:
S3_BUCKET: "my-bucket"
S3_REGION: "us-east-1"
- S3_FORCE_PATH_STYLE: "false" # false for AWS/R2, true for MinIO
+ S3_FORCE_PATH_STYLE: "false" # false for AWS/R2, true for RustFS
secrets:
s3AccessKeyId: "AKIA..."
@@ -281,8 +281,8 @@ bot:
| `secrets.postgresPassword` | PostgreSQL password | `""` |
| `secrets.betterAuthSecret` | better-auth secret | `""` |
| `secrets.appEncryptionKey` | AES encryption key for secrets at rest | `""` |
-| `secrets.s3AccessKeyId` | S3 access key (also MinIO root user) | `""` |
-| `secrets.s3SecretAccessKey` | S3 secret key (also MinIO root password) | `""` |
+| `secrets.s3AccessKeyId` | S3 access key (also RustFS root user) | `""` |
+| `secrets.s3SecretAccessKey` | S3 secret key (also RustFS root password) | `""` |
### External services
@@ -308,16 +308,14 @@ bot:
| `postgresql.tolerations` | Tolerations | `[]` |
| `postgresql.affinity` | Affinity | `{}` |
-### MinIO
+### Object store (RustFS)
| Key | Description | Default |
|----------------------------------|-----------------------------------------|--------------------------------|
-| `minio.enabled` | Deploy MinIO in-cluster | `true` |
+| `minio.enabled` | Deploy RustFS in-cluster | `true` |
| `minio.bucket` | Bucket name to create | `planner-attachments` |
-| `minio.image.repository` | Image repository | `minio/minio` |
-| `minio.image.tag` | Image tag | `RELEASE.2025-04-22T22-12-26Z` |
-| `minio.mcImage.repository` | MinIO Client image repository | `minio/mc` |
-| `minio.mcImage.tag` | MinIO Client image tag | `RELEASE.2025-04-16T18-13-36Z` |
+| `minio.image.repository` | Image repository | `rustfs/rustfs` |
+| `minio.image.tag` | Image tag | `1.0.0` |
| `minio.persistence.size` | PVC size | `20Gi` |
| `minio.persistence.storageClass` | Storage class (empty = cluster default) | `""` |
| `minio.resources` | CPU/memory requests and limits | `{}` |
diff --git a/charts/itsaplan/templates/NOTES.txt b/charts/itsaplan/templates/NOTES.txt
index 637958a9..e3f1fb29 100644
--- a/charts/itsaplan/templates/NOTES.txt
+++ b/charts/itsaplan/templates/NOTES.txt
@@ -29,5 +29,5 @@ PostgreSQL is deployed in-cluster. Data is persisted via a {{ .Values.postgresql
{{- if .Values.minio.enabled }}
-MinIO is deployed in-cluster for S3-compatible attachment storage ({{ .Values.minio.persistence.size }} PVC).
+RustFS is deployed in-cluster for S3-compatible attachment storage ({{ .Values.minio.persistence.size }} PVC).
{{- end }}
diff --git a/charts/itsaplan/templates/_helpers.tpl b/charts/itsaplan/templates/_helpers.tpl
index 1120dd16..de3692a1 100644
--- a/charts/itsaplan/templates/_helpers.tpl
+++ b/charts/itsaplan/templates/_helpers.tpl
@@ -56,7 +56,7 @@ Otherwise, use the override in .Values.externalDatabase.url.
{{/*
Compute the S3 endpoint.
-When the built-in MinIO is enabled, use the internal MinIO service URL.
+When the built-in store is enabled, use its internal service URL.
Otherwise, use the override in .Values.externalS3.endpoint.
*/}}
{{- define "itsaplan.s3Endpoint" -}}
diff --git a/charts/itsaplan/templates/deployment-minio.yaml b/charts/itsaplan/templates/deployment-minio.yaml
index 91101568..62964ea7 100644
--- a/charts/itsaplan/templates/deployment-minio.yaml
+++ b/charts/itsaplan/templates/deployment-minio.yaml
@@ -8,6 +8,9 @@ metadata:
app.kubernetes.io/component: minio
spec:
replicas: 1
+ # Two servers must never open the same data directory, which a rolling update does.
+ strategy:
+ type: Recreate
selector:
matchLabels:
{{- include "itsaplan.selectorLabels" . | nindent 6 }}
@@ -35,15 +38,14 @@ spec:
{{- toYaml . | nindent 8 }}
{{- end }}
containers:
+ # RustFS. The volume may hold files an earlier MinIO release of this chart wrote as
+ # root; RustFS reads them in place and runs as root to keep them writable.
- name: minio
image: "{{ .Values.minio.image.repository }}:{{ .Values.minio.image.tag }}"
imagePullPolicy: IfNotPresent
- command:
- - minio
- - server
- - /data
- - --console-address
- - ":9001"
+ securityContext:
+ runAsUser: 0
+ runAsGroup: 0
ports:
- name: api
containerPort: 9000
@@ -52,25 +54,25 @@ spec:
containerPort: 9001
protocol: TCP
env:
- - name: MINIO_ROOT_USER
+ - name: RUSTFS_ACCESS_KEY
valueFrom:
secretKeyRef:
name: {{ include "itsaplan.fullname" . }}
key: S3_ACCESS_KEY_ID
- - name: MINIO_ROOT_PASSWORD
+ - name: RUSTFS_SECRET_KEY
valueFrom:
secretKeyRef:
name: {{ include "itsaplan.fullname" . }}
key: S3_SECRET_ACCESS_KEY
readinessProbe:
httpGet:
- path: /minio/health/ready
+ path: /health
port: api
initialDelaySeconds: 10
periodSeconds: 10
livenessProbe:
httpGet:
- path: /minio/health/live
+ path: /health
port: api
initialDelaySeconds: 30
periodSeconds: 10
diff --git a/charts/itsaplan/templates/job-minio-init.yaml b/charts/itsaplan/templates/job-minio-init.yaml
index c7e02f16..689c250c 100644
--- a/charts/itsaplan/templates/job-minio-init.yaml
+++ b/charts/itsaplan/templates/job-minio-init.yaml
@@ -24,23 +24,24 @@ spec:
{{- end }}
containers:
- name: minio-init
- image: "{{ .Values.minio.mcImage.repository }}:{{ .Values.minio.mcImage.tag }}"
+ image: "{{ .Values.minio.image.repository }}:{{ .Values.minio.image.tag }}"
command:
- /bin/sh
- -c
- |
- until mc alias set minio http://{{ include "itsaplan.fullname" . }}-minio:9000 "$MINIO_ROOT_USER" "$MINIO_ROOT_PASSWORD"; do
- echo "Waiting for MinIO..."
+ until curl -fsS -o /dev/null http://{{ include "itsaplan.fullname" . }}-minio:9000/health; do
+ echo "Waiting for the object store..."
sleep 2
done
- mc mb --ignore-existing minio/{{ .Values.minio.bucket }}
+ curl -fsS -X PUT --aws-sigv4 aws:amz:us-east-1:s3 --user "$S3_ACCESS_KEY_ID:$S3_SECRET_ACCESS_KEY" \
+ http://{{ include "itsaplan.fullname" . }}-minio:9000/{{ .Values.minio.bucket }}
env:
- - name: MINIO_ROOT_USER
+ - name: S3_ACCESS_KEY_ID
valueFrom:
secretKeyRef:
name: {{ include "itsaplan.fullname" . }}
key: S3_ACCESS_KEY_ID
- - name: MINIO_ROOT_PASSWORD
+ - name: S3_SECRET_ACCESS_KEY
valueFrom:
secretKeyRef:
name: {{ include "itsaplan.fullname" . }}
diff --git a/charts/itsaplan/values.yaml b/charts/itsaplan/values.yaml
index 4221caa1..b627376a 100644
--- a/charts/itsaplan/values.yaml
+++ b/charts/itsaplan/values.yaml
@@ -187,16 +187,14 @@ postgresql:
tolerations: []
affinity: {}
-# -- MinIO
+# -- In-cluster S3 store (RustFS). The key keeps its MinIO-era name so existing values
+# files and the PVC carry over.
minio:
enabled: true
bucket: "planner-attachments"
image:
- repository: quay.io/minio/minio
- tag: "RELEASE.2025-09-07T16-13-09Z"
- mcImage:
- repository: quay.io/minio/mc
- tag: "RELEASE.2025-08-13T08-35-41Z"
+ repository: rustfs/rustfs
+ tag: "1.0.0"
persistence:
size: 20Gi
storageClass: ""
diff --git a/docker-compose.coolify-images.yml b/docker-compose.coolify-images.yml
index ddf0b3c8..c8965bf3 100644
--- a/docker-compose.coolify-images.yml
+++ b/docker-compose.coolify-images.yml
@@ -1,5 +1,5 @@
# ─────────────────────────────────────────────────────────────
-# Coolify stack on the published images: postgres + minio + api + worker + bot + web.
+# Coolify stack on the published images: postgres + rustfs + api + worker + bot + web.
# In Coolify: New Resource → Docker Compose Empty → paste this file. Nothing is built;
# the four services run the images published to GHCR on each release, and VERSION picks
# one (unset means the newest).
@@ -37,44 +37,51 @@ services:
timeout: 5s
retries: 10
- # S3-compatible object store for issue attachments (MinIO).
+ # S3-compatible object store for issue attachments (RustFS).
# Both the S3 API (:9000) and the console (:9001) are internal only — the api
# streams attachment bytes over the internal network, so no port is published.
- # Administer through mc from inside the network or an SSH tunnel.
+ # Administer through an S3 client from inside the network or an SSH tunnel.
+ #
+ # The service, its volume and the SERVICE_*_MINIO credentials keep the names of the
+ # MinIO stack this replaced: a renamed service would leave the old MinIO container
+ # running on the same volume, a renamed volume would start empty, and renamed
+ # credentials would be generated anew. RustFS reads the files MinIO wrote in place;
+ # MinIO wrote them as root, so the container runs as root to keep them writable.
minio:
- image: quay.io/minio/minio:latest
+ image: rustfs/rustfs:1.0.0
restart: unless-stopped
- command: server /data --console-address ":9001"
+ user: '0:0'
environment:
- MINIO_ROOT_USER: ${SERVICE_USER_MINIO}
- MINIO_ROOT_PASSWORD: ${SERVICE_PASSWORD_MINIO}
+ RUSTFS_ACCESS_KEY: ${SERVICE_USER_MINIO}
+ RUSTFS_SECRET_KEY: ${SERVICE_PASSWORD_MINIO}
volumes:
- minio-data:/data
healthcheck:
- test: ['CMD', 'mc', 'ready', 'local']
+ test: ['CMD', 'curl', '-fsS', '-o', '/dev/null', 'http://127.0.0.1:9000/health']
interval: 15s
timeout: 5s
retries: 5
start_period: 20s
- # One-shot: waits for MinIO, creates the attachments bucket, then exits.
+ # One-shot: creates the attachments bucket, then exits. A PUT on a bucket that
+ # already exists succeeds, so it runs on every start.
# restart "no" is explicit: it exits 0 by design, and platforms that inject
# restart: unless-stopped (e.g. Coolify) would otherwise loop it forever and
# trip their restart-count limit, tearing the whole stack down.
minio-init:
- image: quay.io/minio/mc:latest
+ image: rustfs/rustfs:1.0.0
restart: 'no'
depends_on:
- - minio
+ minio:
+ condition: service_healthy
environment:
- MINIO_ROOT_USER: ${SERVICE_USER_MINIO}
- MINIO_ROOT_PASSWORD: ${SERVICE_PASSWORD_MINIO}
+ S3_ACCESS_KEY_ID: ${SERVICE_USER_MINIO}
+ S3_SECRET_ACCESS_KEY: ${SERVICE_PASSWORD_MINIO}
S3_BUCKET: ${S3_BUCKET:-planner-attachments}
entrypoint: >
/bin/sh -c "
- until mc alias set local http://minio:9000 \"$$MINIO_ROOT_USER\" \"$$MINIO_ROOT_PASSWORD\"; do echo 'waiting for minio...'; sleep 2; done;
- mc mb --ignore-existing local/\"$$S3_BUCKET\";
- echo 'bucket ready: '\"$$S3_BUCKET\";
+ curl -fsS -X PUT --aws-sigv4 aws:amz:us-east-1:s3 --user \"$$S3_ACCESS_KEY_ID:$$S3_SECRET_ACCESS_KEY\" http://minio:9000/\"$$S3_BUCKET\" &&
+ echo 'bucket ready: '\"$$S3_BUCKET\"
"
api:
diff --git a/docker-compose.coolify.yml b/docker-compose.coolify.yml
index 5dbc235e..1395e6ec 100644
--- a/docker-compose.coolify.yml
+++ b/docker-compose.coolify.yml
@@ -1,5 +1,5 @@
# ─────────────────────────────────────────────────────────────
-# Coolify stack: postgres + minio + api + worker + bot + web.
+# Coolify stack: postgres + rustfs + api + worker + bot + web.
# In Coolify: New Resource → Docker Compose → point to this file, then set the
# environment variables (see .env.example) in the UI.
#
@@ -34,44 +34,51 @@ services:
timeout: 5s
retries: 10
- # S3-compatible object store for issue attachments (MinIO).
+ # S3-compatible object store for issue attachments (RustFS).
# Both the S3 API (:9000) and the console (:9001) are internal only — the api
# streams attachment bytes over the internal network, so no port is published.
- # Administer through mc from inside the network or an SSH tunnel.
+ # Administer through an S3 client from inside the network or an SSH tunnel.
+ #
+ # The service, its volume and the SERVICE_*_MINIO credentials keep the names of the
+ # MinIO stack this replaced: a renamed service would leave the old MinIO container
+ # running on the same volume, a renamed volume would start empty, and renamed
+ # credentials would be generated anew. RustFS reads the files MinIO wrote in place;
+ # MinIO wrote them as root, so the container runs as root to keep them writable.
minio:
- image: quay.io/minio/minio:latest
+ image: rustfs/rustfs:1.0.0
restart: unless-stopped
- command: server /data --console-address ":9001"
+ user: '0:0'
environment:
- MINIO_ROOT_USER: ${SERVICE_USER_MINIO}
- MINIO_ROOT_PASSWORD: ${SERVICE_PASSWORD_MINIO}
+ RUSTFS_ACCESS_KEY: ${SERVICE_USER_MINIO}
+ RUSTFS_SECRET_KEY: ${SERVICE_PASSWORD_MINIO}
volumes:
- minio-data:/data
healthcheck:
- test: ['CMD', 'mc', 'ready', 'local']
+ test: ['CMD', 'curl', '-fsS', '-o', '/dev/null', 'http://127.0.0.1:9000/health']
interval: 15s
timeout: 5s
retries: 5
start_period: 20s
- # One-shot: waits for MinIO, creates the attachments bucket, then exits.
+ # One-shot: creates the attachments bucket, then exits. A PUT on a bucket that
+ # already exists succeeds, so it runs on every start.
# restart "no" is explicit: it exits 0 by design, and platforms that inject
# restart: unless-stopped (e.g. Coolify) would otherwise loop it forever and
# trip their restart-count limit, tearing the whole stack down.
minio-init:
- image: quay.io/minio/mc:latest
+ image: rustfs/rustfs:1.0.0
restart: 'no'
depends_on:
- - minio
+ minio:
+ condition: service_healthy
environment:
- MINIO_ROOT_USER: ${SERVICE_USER_MINIO}
- MINIO_ROOT_PASSWORD: ${SERVICE_PASSWORD_MINIO}
+ S3_ACCESS_KEY_ID: ${SERVICE_USER_MINIO}
+ S3_SECRET_ACCESS_KEY: ${SERVICE_PASSWORD_MINIO}
S3_BUCKET: ${S3_BUCKET:-planner-attachments}
entrypoint: >
/bin/sh -c "
- until mc alias set local http://minio:9000 \"$$MINIO_ROOT_USER\" \"$$MINIO_ROOT_PASSWORD\"; do echo 'waiting for minio...'; sleep 2; done;
- mc mb --ignore-existing local/\"$$S3_BUCKET\";
- echo 'bucket ready: '\"$$S3_BUCKET\";
+ curl -fsS -X PUT --aws-sigv4 aws:amz:us-east-1:s3 --user \"$$S3_ACCESS_KEY_ID:$$S3_SECRET_ACCESS_KEY\" http://minio:9000/\"$$S3_BUCKET\" &&
+ echo 'bucket ready: '\"$$S3_BUCKET\"
"
api:
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index 6f295bff..64a6da4b 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,10 +1,10 @@
# ─────────────────────────────────────────────────────────────
# Local development: brings up the backing services the app needs — Postgres and
-# MinIO — with host-published ports, so one command starts them together instead
+# RustFS — with host-published ports, so one command starts them together instead
# of running each by hand. The api, web, worker, and Telegram bot apps run on the
# host via `bun run dev` (watch/hot-reload, turbo) and reach these over localhost.
#
-# docker compose -f docker-compose.dev.yml up -d # starts postgres + minio (+ bucket init)
+# docker compose -f docker-compose.dev.yml up -d # starts postgres + rustfs (+ bucket init)
#
# If host port 5432 is taken (a local Postgres is already running),
# pick another: POSTGRES_PORT=5433 docker compose -f docker-compose.dev.yml up -d
@@ -33,38 +33,48 @@ services:
timeout: 5s
retries: 10
- # S3-compatible object store for issue attachments (MinIO).
+ # S3-compatible object store for issue attachments (RustFS).
# The attachments bucket is created by the minio-init service below.
# S3 API: http://localhost:9000
- # Web console: http://localhost:9001
+ # Web console: http://localhost:9001/rustfs/console/
# login with S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY from .env
+ #
+ # The service and volume keep their MinIO-era names so an existing dev stack
+ # upgrades in place: RustFS reads the files MinIO wrote, and runs as root because
+ # MinIO wrote them as root.
minio:
- image: quay.io/minio/minio:latest
+ image: rustfs/rustfs:1.0.0
restart: unless-stopped
- command: server /data --console-address ":9001"
+ user: '0:0'
environment:
- MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID:-minioadmin}
- MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY:-minioadmin}
+ RUSTFS_ACCESS_KEY: ${S3_ACCESS_KEY_ID:-minioadmin}
+ RUSTFS_SECRET_KEY: ${S3_SECRET_ACCESS_KEY:-minioadmin}
ports:
- '9000:9000'
- '9001:9001'
volumes:
- minio-dev-data:/data
+ healthcheck:
+ test: ['CMD', 'curl', '-fsS', '-o', '/dev/null', 'http://127.0.0.1:9000/health']
+ interval: 5s
+ timeout: 5s
+ retries: 10
- # One-shot: waits for MinIO, creates the attachments bucket, then exits.
+ # One-shot: creates the attachments bucket, then exits. A PUT on a bucket that
+ # already exists succeeds, so it runs on every start.
minio-init:
- image: quay.io/minio/mc:latest
+ image: rustfs/rustfs:1.0.0
depends_on:
- - minio
+ minio:
+ condition: service_healthy
environment:
- MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID:-minioadmin}
- MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY:-minioadmin}
+ S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-minioadmin}
+ S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-minioadmin}
S3_BUCKET: ${S3_BUCKET:-planner-attachments}
entrypoint: >
/bin/sh -c "
- until mc alias set local http://minio:9000 \"$$MINIO_ROOT_USER\" \"$$MINIO_ROOT_PASSWORD\"; do echo 'waiting for minio...'; sleep 2; done;
- mc mb --ignore-existing local/\"$$S3_BUCKET\";
- echo 'bucket ready: '\"$$S3_BUCKET\";
+ curl -fsS -X PUT --aws-sigv4 aws:amz:us-east-1:s3 --user \"$$S3_ACCESS_KEY_ID:$$S3_SECRET_ACCESS_KEY\" http://minio:9000/\"$$S3_BUCKET\" &&
+ echo 'bucket ready: '\"$$S3_BUCKET\"
"
volumes:
diff --git a/docker-compose.test.yml b/docker-compose.test.yml
index e5253780..73202421 100644
--- a/docker-compose.test.yml
+++ b/docker-compose.test.yml
@@ -46,27 +46,31 @@ services:
timeout: 3s
retries: 20
- # Throwaway MinIO for the attachments feature test (object bytes). Ephemeral:
+ # Throwaway RustFS for the attachments feature test (object bytes). Ephemeral:
# /data is tmpfs, wiped when the run ends.
- minio-test:
- image: quay.io/minio/minio:latest
- command: server /data
+ rustfs-test:
+ image: rustfs/rustfs:1.0.0
environment:
- MINIO_ROOT_USER: minioadmin
- MINIO_ROOT_PASSWORD: minioadmin
+ RUSTFS_ACCESS_KEY: minioadmin
+ RUSTFS_SECRET_KEY: minioadmin
tmpfs:
- - /data
+ - /data:uid=10001,gid=10001
+ healthcheck:
+ test: ['CMD', 'curl', '-fsS', '-o', '/dev/null', 'http://127.0.0.1:9000/health']
+ interval: 3s
+ timeout: 3s
+ retries: 20
- # One-shot: waits for MinIO, creates the attachments bucket, then exits.
- minio-test-init:
- image: quay.io/minio/mc:latest
+ # One-shot: creates the attachments bucket, then exits.
+ rustfs-test-init:
+ image: rustfs/rustfs:1.0.0
depends_on:
- - minio-test
+ rustfs-test:
+ condition: service_healthy
entrypoint: >
sh -c "
- until mc alias set local http://minio-test:9000 minioadmin minioadmin; do echo 'waiting for minio...'; sleep 2; done;
- mc mb --ignore-existing local/planner-attachments;
- echo 'bucket ready';
+ curl -fsS -X PUT --aws-sigv4 aws:amz:us-east-1:s3 --user minioadmin:minioadmin http://rustfs-test:9000/planner-attachments &&
+ echo 'bucket ready'
"
api-test:
@@ -83,7 +87,7 @@ services:
depends_on:
postgres-test:
condition: service_healthy
- minio-test-init:
+ rustfs-test-init:
condition: service_completed_successfully
environment:
NODE_ENV: test
@@ -94,8 +98,8 @@ services:
APP_ENCRYPTION_KEY: dGVzdC1lbmNyeXB0aW9uLWtleS0zMmJ5dGVzLWxlbiE=
API_URL: http://localhost:3000
APP_URL: http://localhost:3001
- # Object store for the attachments test (throwaway MinIO above).
- S3_ENDPOINT: http://minio-test:9000
+ # Object store for the attachments test (throwaway RustFS above).
+ S3_ENDPOINT: http://rustfs-test:9000
S3_REGION: us-east-1
S3_BUCKET: planner-attachments
S3_ACCESS_KEY_ID: minioadmin
diff --git a/docker-compose.yml b/docker-compose.yml
index 523d12d3..b47b2542 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,5 +1,5 @@
# ─────────────────────────────────────────────────────────────
-# Self-hosting stack: postgres + minio + api + worker + bot + web.
+# Self-hosting stack: postgres + rustfs + api + worker + bot + web.
# Coolify uses docker-compose.coolify.yml; local dev uses docker-compose.dev.yml
# (backing services only).
#
@@ -35,41 +35,47 @@ services:
timeout: 5s
retries: 10
- # S3-compatible object store for issue attachments.
+ # S3-compatible object store for issue attachments (RustFS).
# Both the S3 API (:9000) and the console (:9001) stay inside the compose
# network: the api streams attachment bytes through itself, so no port is
- # published. Administer through mc from inside the network or an SSH tunnel.
+ # published. Administer through an S3 client from inside the network or an SSH tunnel.
+ #
+ # The service and volume keep the names of the MinIO stack this replaced: a renamed
+ # service would leave the old MinIO container running on the same volume, and a
+ # renamed volume would start empty. RustFS reads the files MinIO wrote in place;
+ # MinIO wrote them as root, so the container runs as root to keep them writable.
minio:
- image: quay.io/minio/minio:latest
+ image: rustfs/rustfs:1.0.0
restart: unless-stopped
- command: server /data --console-address ":9001"
+ user: '0:0'
environment:
- MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID:?set S3_ACCESS_KEY_ID in .env}
- MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY:?set S3_SECRET_ACCESS_KEY in .env}
+ RUSTFS_ACCESS_KEY: ${S3_ACCESS_KEY_ID:?set S3_ACCESS_KEY_ID in .env}
+ RUSTFS_SECRET_KEY: ${S3_SECRET_ACCESS_KEY:?set S3_SECRET_ACCESS_KEY in .env}
volumes:
- minio-data:/data
healthcheck:
- test: ['CMD', 'mc', 'ready', 'local']
+ test: ['CMD', 'curl', '-fsS', '-o', '/dev/null', 'http://127.0.0.1:9000/health']
interval: 15s
timeout: 5s
retries: 5
start_period: 20s
- # One-shot: waits for MinIO, creates the attachments bucket, then exits.
+ # One-shot: creates the attachments bucket, then exits. A PUT on a bucket that
+ # already exists succeeds, so it runs on every start.
minio-init:
- image: quay.io/minio/mc:latest
+ image: rustfs/rustfs:1.0.0
restart: 'no'
depends_on:
- - minio
+ minio:
+ condition: service_healthy
environment:
- MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID}
- MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY}
+ S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID}
+ S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY}
S3_BUCKET: ${S3_BUCKET:-planner-attachments}
entrypoint: >
/bin/sh -c "
- until mc alias set local http://minio:9000 \"$$MINIO_ROOT_USER\" \"$$MINIO_ROOT_PASSWORD\"; do echo 'waiting for minio...'; sleep 2; done;
- mc mb --ignore-existing local/\"$$S3_BUCKET\";
- echo 'bucket ready: '\"$$S3_BUCKET\";
+ curl -fsS -X PUT --aws-sigv4 aws:amz:us-east-1:s3 --user \"$$S3_ACCESS_KEY_ID:$$S3_SECRET_ACCESS_KEY\" http://minio:9000/\"$$S3_BUCKET\" &&
+ echo 'bucket ready: '\"$$S3_BUCKET\"
"
# Applies database migrations on startup, then serves the API.
diff --git a/docs/coolify.md b/docs/coolify.md
index c843e8ea..f292c079 100644
--- a/docs/coolify.md
+++ b/docs/coolify.md
@@ -50,10 +50,10 @@ change.
## 4. Deploy
-Press **Deploy**. Postgres, MinIO, api, worker, bot, and web come up together; the api
+Press **Deploy**. Postgres, RustFS, api, worker, bot, and web come up together; the api
applies the migrations on startup. The first account registered becomes the instance admin.
-Secrets (database password, auth secret, encryption key, worker token, MinIO credentials)
+Secrets (database password, auth secret, encryption key, worker token, object store credentials)
are generated on the first deploy and stay stable across later ones — nothing to fill in by
hand. Optional variables from `.env.example` — legal document URLs, telemetry opt-out,
worker tuning — go in **Configuration → Environment Variables**.
diff --git a/docs/development.md b/docs/development.md
index 64411107..37173b5a 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -12,13 +12,13 @@ bun run setup # "Develop", or "Generate env" for just the .env files
bun run dev # api + web together, via Turborepo
```
-**Develop** writes the env files, generates the secrets, starts Postgres and MinIO, creates
+**Develop** writes the env files, generates the secrets, starts Postgres and RustFS, creates
the test database, and migrates both. Run it again any time: it restarts the stack and
re-applies the migrations, keeping the data. It offers another port when one is taken, and
offers to stop the **Try it** stack, which publishes the same ones.
`bun run dev` runs the workspace in watch mode: web on <http://localhost:3001>, api on
-<http://localhost:3000>, MinIO console on <http://localhost:9001>. Only Postgres and MinIO
+<http://localhost:3000>, RustFS console on <http://localhost:9001/rustfs/console/>. Only Postgres and RustFS
run in Docker; the apps run on the host.
## Environment
diff --git a/docs/helm.md b/docs/helm.md
index e1ca8bef..0961677a 100644
--- a/docs/helm.md
+++ b/docs/helm.md
@@ -1,7 +1,7 @@
# Deploy on Kubernetes (Helm)
The Helm chart in `charts/itsaplan/` deploys the full stack on any Kubernetes 1.24+ cluster. It runs the published
-images from GHCR, with built-in PostgreSQL and MinIO that can each be swapped for an external service.
+images from GHCR, with built-in PostgreSQL and RustFS that can each be swapped for an external service.
## Prerequisites
@@ -44,8 +44,8 @@ The API applies database migrations on startup. The first account registered bec
| Worker | Deployment | always |
| Bot (Telegram) | Deployment | `bot.enabled` (default `true`) |
| PostgreSQL | StatefulSet + Service + PVC | `postgresql.enabled` (default `true`) |
-| MinIO | Deployment + Service + PVC | `minio.enabled` (default `true`) |
-| MinIO bucket init | Job (Helm hook) | `minio.enabled` |
+| RustFS | Deployment + Service + PVC | `minio.enabled` (default `true`) |
+| RustFS bucket init | Job (Helm hook) | `minio.enabled` |
Ingress, TLS certificates, and a ServiceAccount are available but disabled by default.
@@ -125,7 +125,7 @@ externalDatabase:
## External S3
-Disable the built-in MinIO and point to an external S3-compatible store:
+Disable the built-in RustFS and point to an external S3-compatible store:
```yaml
minio:
@@ -145,7 +145,7 @@ secrets:
s3SecretAccessKey: "..."
```
-`S3_FORCE_PATH_STYLE` is `false` for AWS and Cloudflare R2, `true` for MinIO.
+`S3_FORCE_PATH_STYLE` is `false` for AWS and Cloudflare R2, `true` for RustFS.
## Secrets in production
diff --git a/docs/railway.md b/docs/railway.md
index ff312341..d9546e5b 100644
--- a/docs/railway.md
+++ b/docs/railway.md
@@ -63,7 +63,7 @@ Configure Auto Updates**, or narrow the window there.
Secrets — auth secret, encryption key, worker token, database password — are generated per
deploy and never stored in the template. Attachments go to the Railway bucket, which is why
-`S3_FORCE_PATH_STYLE` is `false` here; MinIO in the Compose stack needs the default.
+`S3_FORCE_PATH_STYLE` is `false` here; RustFS in the Compose stack needs the default.
To run the same stack elsewhere, see [self-hosting.md](self-hosting.md) or
[coolify.md](coolify.md).
diff --git a/docs/self-hosting.md b/docs/self-hosting.md
index c6f2e5a1..a4b61bf1 100644
--- a/docs/self-hosting.md
+++ b/docs/self-hosting.md
@@ -19,14 +19,14 @@ The stack refuses to start while one of these is missing:
| `POSTGRES_PASSWORD` | `openssl rand -base64 32` |
| `BETTER_AUTH_SECRET` | `openssl rand -base64 32` |
| `APP_ENCRYPTION_KEY` | `openssl rand -base64 32` |
-| `S3_ACCESS_KEY_ID` | the MinIO root user, any name over 3 chars |
+| `S3_ACCESS_KEY_ID` | the RustFS root user, any name over 3 chars |
| `S3_SECRET_ACCESS_KEY` | `openssl rand -base64 32` |
On a machine with [Bun](https://bun.sh), the setup script generates them instead. Run
`bun install && bun run setup`, answer **Generate env**, and answer no when it offers to
write the files: it prints `.env` and `apps/web/.env` for you to copy onto the server.
-That starts the whole stack: Postgres, MinIO, api, worker, bot, and web. The four services
+That starts the whole stack: Postgres, RustFS, api, worker, bot, and web. The four services
run from the images published on each release. `VERSION` in `.env` pins one release instead
of the newest. The api applies migrations when it starts, and the first account you register
becomes the instance admin.
@@ -117,6 +117,16 @@ days, on the first startup past that; `BACKUP_RETENTION_DAYS` changes the window
other means. After the upgrade the app shows the instance owner where the dump is and
what the migrations changed.
+Attachments are stored in RustFS. An instance set up with MinIO switches to it on the next
+`docker compose up -d`: the `minio` service keeps its name and its `minio-data` volume, and
+RustFS reads the files MinIO wrote in place, with the same credentials. Nothing is copied,
+and the files stay readable by MinIO. The upgrade touches no attachment data, but a copy of
+the volume before it costs one command:
+
+```bash
+docker run --rm -v itsaplan_minio-data:/data -v "$PWD":/out alpine tar czf /out/minio-data.tgz -C /data .
+```
+
If you call the API from your own scripts or from an MCP client, read
[breaking changes](breaking-changes.md) for the paths a release removed.
diff --git a/packages/storage/src/index.ts b/packages/storage/src/index.ts
index a9bda38e..fec9fa2c 100644
--- a/packages/storage/src/index.ts
+++ b/packages/storage/src/index.ts
@@ -6,15 +6,15 @@ import {
DeleteObjectCommand,
} from '@aws-sdk/client-s3';
-// S3-compatible object store (MinIO) for attachments — api's issue/chat/document/
+// S3-compatible object store (RustFS in the Compose stacks) for attachments — api's issue/chat/document/
// initiative attachments and the worker's imported issue attachments alike. Only
// the file bytes live here; the metadata and object key are rows in whichever
// table owns them (issue_attachment, chat_attachment, ...).
//
-// Config comes from env. forcePathStyle is required for MinIO (and most
+// Config comes from env. forcePathStyle is required for RustFS (and most
// self-hosted S3 gateways) because they do not serve virtual-host-style buckets;
// hosted stores that only serve virtual-host-style buckets set
-// S3_FORCE_PATH_STYLE=false. region is sent but ignored by MinIO; a value is
+// S3_FORCE_PATH_STYLE=false. region is sent but ignored by RustFS; a value is
// still required by the SDK.
let cached: { client: S3Client; bucket: string } | null = null;
diff --git a/scripts/setup.ts b/scripts/setup.ts
index 82a247ff..50fa3341 100644
--- a/scripts/setup.ts
+++ b/scripts/setup.ts
@@ -224,7 +224,7 @@ const mode = answer(
{
value: 'dev',
label: 'Develop',
- hint: 'Postgres and MinIO in Docker, the apps on your machine',
+ hint: 'Postgres and RustFS in Docker, the apps on your machine',
},
{ value: 'env', label: 'Generate env', hint: 'the secrets and every value, step by step' },
],
@@ -355,7 +355,7 @@ if (mode === 'dev') {
}
await stopOther(['docker', 'compose'], 'Try it');
- // The PR stack fixes the MinIO ports in its own compose file, so no port question can
+ // The PR stack fixes the RustFS ports in its own compose file, so no port question can
// resolve an overlap with the dev one.
await stopOther(
['docker', 'compose', '-f', 'docker-compose.dev.pr.yml'],
@@ -384,11 +384,11 @@ if (mode === 'dev') {
web.save();
const spinner = p.spinner();
- spinner.start('Starting Postgres and MinIO');
+ spinner.start('Starting Postgres and RustFS');
await run(...compose, 'up', '-d');
// --wait names postgres only: minio-init is a one-shot and its exit counts as a failure.
await run(...compose, 'up', '-d', '--wait', '--no-recreate', 'postgres');
- spinner.stop('Postgres and MinIO are up');
+ spinner.stop('Postgres and RustFS are up');
await matchPort(compose, dbPort);
await matchCredentials(compose, env);