RustFS

https://docs.rustfs.com
Admin
RustFS is a high-performance, distributed object storage software written in Rust that is 100%...
Tokens:311,962
Snippets:2,807
Trust Score:7.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Installation success output

Source: https://docs.rustfs.com/en/installation/linux/quick-start

Example output printed by the installation script on success. Includes the service and console ports, data directory, and a security warning to change default credentials.

```text
RustFS has been installed and started successfully!
Service port: 9000,  Console port: 9001,  Data directory: /data/rustfs0

[SECURITY WARNING] Please change the default value for RUSTFS_ACCESS_KEY/RUSTFS_SECRET_KEY immediately ...
  Config file: /etc/default/rustfs
```

--------------------------------

### Install RustFS with official script

Source: https://docs.rustfs.com/en/installation/linux/quick-start

Downloads and runs the official RustFS installation script. Installs the binary to /usr/local/bin/rustfs, registers a systemd service, and starts it. Defaults to data in /data/rustfs0 and ports 9000 (S3 API) and 9001 (Console).

```bash
curl -O https://rustfs.com/install_rustfs.sh && bash install_rustfs.sh
```

--------------------------------

### Example CLI invocations for rustfs subcommands

Source: https://docs.rustfs.com/en/reference/cli

Shows example invocations for the server, info, and tls inspect subcommands. The server command starts the object storage server, info displays system and runtime details, and tls inspect checks a certificate directory.

```bash
rustfs server /data/rustfs
rustfs info --all --json
rustfs tls inspect --path /etc/rustfs/tls
```

--------------------------------

### Start services and wait for Elasticsearch

Source: https://docs.rustfs.com/en/developer/integration/devops/elasticsearch

Starts the Docker Compose stack and checks that Elasticsearch is up. The first start installs the plugin and creates keystore entries, which takes a minute or two.

```bash
docker compose up -d
curl -s http://localhost:9200
```

--------------------------------

### Download and install RustFS binary

Source: https://docs.rustfs.com/en/installation/linux/prerequisites-and-service

Downloads the RustFS binary, extracts it, makes it executable, and installs it to /usr/local/bin. Requires wget or curl to be installed first.

```bash
# Download address
wget https://dl.rustfs.com/artifacts/rustfs/release/rustfs-linux-x86_64-musl-latest.zip
unzip rustfs-linux-x86_64-musl-latest.zip
chmod +x rustfs
mv rustfs /usr/local/bin/
```

--------------------------------

### Run Airflow standalone and create demo bucket

Source: https://docs.rustfs.com/en/developer/integration/big-data/airflow

Starts a standalone Airflow 3.3.2 container on the oo-rustfs_default network with examples disabled, mounts the local dags directory, and creates the demo bucket rustfs/airflow-demo using the rc CLI.

```bash
docker run -d --name airflow --network oo-rustfs_default -p 8080:8080 \
  -e AIRFLOW__CORE__LOAD_EXAMPLES=False \
  -v "$PWD/dags":/opt/airflow/dags \
  apache/airflow:3.3.2 standalone

rc mb rustfs/airflow-demo
```

--------------------------------

### Install Nextcloud with Docker and occ maintenance:install

Source: https://docs.rustfs.com/en/developer/integration/others/nextcloud

Starts a Nextcloud container with an admin account and, if the web UI still shows the installer, finishes the installation manually via occ. Replace all connection placeholders. SQLite keeps the test self-contained; use MariaDB or PostgreSQL in production.

```bash
docker run -d --name nextcloud --network oo-rustfs_default -p 8080:80 \
  -e NEXTCLOUD_ADMIN_USER=<admin-user> \
  -e NEXTCLOUD_ADMIN_PASSWORD=<admin-password> \
  nextcloud:32.0.15
```

```bash
docker exec -u www-data nextcloud php occ maintenance:install \
  --admin-user <admin-user> --admin-password <admin-password>
```

--------------------------------

### Install Boto3 in a virtual environment

Source: https://docs.rustfs.com/en/developer/sdk/python

Creates a Python virtual environment and installs Boto3. Boto3 depends on botocore, which is installed automatically.

```bash
python3 -m venv venv
source venv/bin/activate
pip install boto3

```

--------------------------------

### Validate and start deployment

Source: https://docs.rustfs.com/en/developer/integration/reverse-proxy/caddy

Commands to render Compose config, start RustFS, validate Caddyfile, start Caddy, and check logs.

```bash
docker compose config
docker compose up -d rustfs
```

```bash
docker compose run --rm --no-deps caddy caddy validate --config /etc/caddy/Caddyfile
```

```bash
docker compose up -d caddy
docker compose ps
docker compose logs --follow caddy
```

--------------------------------

### Enable and start chronyd

Source: https://docs.rustfs.com/en/installation/linux/prerequisites-and-service

Enable and start the chronyd service after configuring chrony.

```bash
sudo systemctl enable chronyd
sudo systemctl start chronyd
```

--------------------------------

### Enable and start ntpd

Source: https://docs.rustfs.com/en/installation/linux/prerequisites-and-service

Enable and start the ntpd service after configuring /etc/ntp.conf.

```bash
sudo systemctl enable ntpd
sudo systemctl start ntpd
```

--------------------------------

### Validate and start the deployment

Source: https://docs.rustfs.com/en/developer/integration/reverse-proxy/nginx

Validate the Compose configuration, start RustFS, and test the Nginx configuration. Then start Nginx and check service status. If a service is not healthy, inspect its logs.

```bash
docker compose config
docker compose up -d rustfs
docker compose run --rm --no-deps nginx nginx -t

```

```bash
docker compose up -d nginx
docker compose ps

```

```bash
docker compose logs nginx
docker compose logs rustfs

```

--------------------------------

### Start RustFS service with systemctl

Source: https://docs.rustfs.com/en/troubleshooting/node

Start the RustFS service on the replacement node using systemctl. After starting, view logs with journalctl to confirm the node detects other online nodes and begins healing.

```bash
systemctl start rustfs
```

--------------------------------

### Validate and start the deployment

Source: https://docs.rustfs.com/en/developer/integration/reverse-proxy/haproxy

Commands to render the Compose configuration, start RustFS, validate the HAProxy configuration, start HAProxy, check service status, and inspect logs if a service does not become healthy.

```bash
docker compose config
docker compose up -d rustfs

```

```bash
docker compose run --rm --no-deps haproxy haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg

```

```bash
docker compose up -d haproxy
docker compose ps

```

```bash
docker compose logs haproxy
docker compose logs rustfs

```

--------------------------------

### Mount all disks and start RustFS

Source: https://docs.rustfs.com/en/troubleshooting/driver

Batch mount all disks and start the RustFS service after replacing the disk.

```bash
mount -a
systemctl start rustfs
```

--------------------------------

### Start and enable rustfs service

Source: https://docs.rustfs.com/en/installation/linux/multiple-node-multiple-disk

Start the RustFS service on every node and enable auto-start on boot.

```bash
sudo systemctl enable --now rustfs
```

--------------------------------

### Install Xcode command-line tools

Source: https://docs.rustfs.com/en/installation/macos

Install the Xcode command-line tools, a prerequisite for building RustFS from source on Intel macOS.

```bash
xcode-select --install
```

--------------------------------

### Initialize S3 client and list buckets (main.go)

Source: https://docs.rustfs.com/en/developer/sdk/go

Complete Go program that reads configuration from environment variables, creates an S3 client pointing to RustFS, and lists buckets. Requires RUSTFS_ACCESS_KEY_ID, RUSTFS_SECRET_ACCESS_KEY, RUSTFS_REGION, and RUSTFS_ENDPOINT_URL to be set.

```go
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

func main() {
	region := os.Getenv("RUSTFS_REGION")
	accessKeyID := os.Getenv("RUSTFS_ACCESS_KEY_ID")
	secretAccessKey := os.Getenv("RUSTFS_SECRET_ACCESS_KEY")
	endpoint := os.Getenv("RUSTFS_ENDPOINT_URL")

	if accessKeyID == "" || secretAccessKey == "" || region == "" || endpoint == "" {
		log.Fatal("missing the env: RUSTFS_ACCESS_KEY_ID / RUSTFS_SECRET_ACCESS_KEY / RUSTFS_REGION / RUSTFS_ENDPOINT_URL")
	}

	// build aws.Config
	cfg := aws.Config{
		Region:      region,
		Credentials: aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
	}

	// build S3 client
	client := s3.NewFromConfig(cfg, func(o *s3.Options) {
		o.BaseEndpoint = aws.String(endpoint)
		// RustFS uses path-style URLs by default; virtual-host style requires RUSTFS_SERVER_DOMAINS
		o.UsePathStyle = true
	})

	ctx := context.Background()

	resp, err := client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		log.Fatalf("list buckets failed: %v", err)
	}

	fmt.Println("Buckets:")
	for _, b := range resp.Buckets {
		fmt.Println(" -", *b.Name)
	}
}
```

--------------------------------

### Create and list a directory with MKCOL and PROPFIND

Source: https://docs.rustfs.com/en/administration/protocols/webdav

Creates a directory (object key prefix) with MKCOL and then lists its contents with PROPFIND. WebDAV directories below a bucket map to object key prefixes.

```bash
curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \
	--request MKCOL \
	"$WEBDAV_URL/my-bucket/docs/"

curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \
	--request PROPFIND \
	--header "Depth: 1" \
	"$WEBDAV_URL/my-bucket/docs/"
```

--------------------------------

### Create deployment directories and set key permissions

Source: https://docs.rustfs.com/en/developer/integration/reverse-proxy/nginx

Create the deployment directories and copy the certificate chain and private key into certs/. Restrict access to the private key with chmod 600.

```bash
mkdir -p rustfs-nginx/sites rustfs-nginx/certs
cd rustfs-nginx
```

```text
rustfs-nginx/
├── certs/
│   ├── fullchain.pem
│   └── privkey.pem
└── sites/
```

```bash
chmod 600 certs/privkey.pem
```

--------------------------------

### Install standalone mode

Source: https://docs.rustfs.com/en/installation/cloud-native

Install RustFS in standalone mode (single node, single disk) by disabling distributed mode and enabling standalone. This is suitable for development or small setups.

```bash
helm install rustfs . -n rustfs --create-namespace \
  --set mode.standalone.enabled=true \
  --set mode.distributed.enabled=false \
  --set secret.rustfs.access_key=<your-access-key> \
  --set secret.rustfs.secret_key=<your-secret-key>
```

--------------------------------

### Run the Go example with environment variables

Source: https://docs.rustfs.com/en/developer/sdk/go

Commands to set the required environment variables and run the Go program. Replace localhost with your server's IP if RustFS runs on another machine.

```bash
export RUSTFS_ENDPOINT_URL="http://localhost:9000"
export RUSTFS_REGION="us-east-1"
export RUSTFS_ACCESS_KEY_ID="<your-access-key>"
export RUSTFS_SECRET_ACCESS_KEY="<your-secret-key>"
go run main.go
```

--------------------------------

### Start the deployment with docker compose

Source: https://docs.rustfs.com/en/developer/integration/observability/openobserve

Start the Compose stack and verify the init-bucket service completes successfully. The expected output confirms the bucket was created; the OpenObserve UI is then available at http://localhost:5080 and the RustFS Console at http://localhost:9001/rustfs/console/.

```bash
docker compose config
docker compose up -d
docker compose ps
```

```text
✓ Bucket 'rustfs/my-bucket' created successfully.
```

--------------------------------

### Two-pool RUSTFS_VOLUMES example

Source: https://docs.rustfs.com/en/operations/scaling/storage-pool-expansion

Example of the complete `RUSTFS_VOLUMES` value in `/etc/default/rustfs` showing two pools. Every node must start with the complete ordered pool list; omitting the existing pool or using a different expression creates an inconsistent topology.

```ini
RUSTFS_VOLUMES="http://rustfs-node1:9000/data/rustfs{1...4}/mnmd http://rustfs-node2:9000/data/rustfs{1...4}/mnmd"
```

--------------------------------

### Install AWS SDK v3 and TypeScript dependencies

Source: https://docs.rustfs.com/en/developer/sdk/typescript

Install the AWS SDK for JavaScript v3 and TypeScript development dependencies. Requires Node.js 18 or later and an ES module setup ("type": "module" in package.json).

```bash
npm install @aws-sdk/client-s3
npm install --save-dev typescript tsx @types/node
```

--------------------------------

### Initialize S3Client and list buckets (main.ts)

Source: https://docs.rustfs.com/en/developer/sdk/typescript

Complete runnable example that initializes an S3Client pointing at a RustFS server and lists buckets. Replace localhost with the server IP and provide your access keys. RustFS uses path-style URLs by default; virtual-host style requires RUSTFS_SERVER_DOMAINS.

```typescript
import {
  S3Client,
  CreateBucketCommand,
  DeleteBucketCommand,
  ListBucketsCommand,
  ListObjectsV2Command,
  PutObjectCommand,
  GetObjectCommand,
} from "@aws-sdk/client-s3";
import * as fs from "fs";

const rustfs_client = new S3Client({
  region: "us-east-1", // RustFS default region
  endpoint: "http://localhost:9000", // RustFS S3 API address
  credentials: {
    accessKeyId: "<your-access-key>",
    secretAccessKey: "<your-secret-key>",
  },
  // RustFS uses path-style URLs by default; virtual-host style requires RUSTFS_SERVER_DOMAINS
  forcePathStyle: true,
});

const response = await rustfs_client.send(new ListBucketsCommand({}));
console.log(response.Buckets?.map((bucket) => bucket.Name) ?? []);
```

--------------------------------

### Create bucket, upload, and list objects

Source: https://docs.rustfs.com/en/developer/integration/others/capo

Create a bucket, upload an object, and list the bucket. The expected output shows the object key and size.

```python
s3.create_bucket(bucket="my-bucket")

s3.put_object(bucket="my-bucket", key="hello.txt", body=b"hello RustFS\n")

for obj in s3.list_objects_v2(bucket="my-bucket").get("contents", []):
    print(obj["key"], obj["size"])

```

```text
hello.txt 13
```

--------------------------------

### Install PyIceberg client

Source: https://docs.rustfs.com/en/developer/integration/big-data/pyiceberg

Creates a directory and an isolated Python environment, then installs PyIceberg 0.10.0 with PyArrow support and boto3. Run these commands before configuring the catalog connection.

```bash
mkdir rustfs-s3-tables
cd rustfs-s3-tables
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install 'pyiceberg[pyarrow]==0.10.0' boto3
```

--------------------------------

### Start RustFS container with command-line flags

Source: https://docs.rustfs.com/en/installation/container/docker

Alternative to the environment-variable example, passing the same settings as command-line flags. When both are present, command-line flags take precedence.

```bash
docker run -d \
  --name rustfs \
  -p 9000:9000 \
  -p 9001:9001 \
  -v rustfs-data:/data \
  rustfs/rustfs:latest \
  --access-key "<your-access-key>" \
  --secret-key "<your-secret-key>" \
  --address :9000 \
  --console-enable \
  /data
```

--------------------------------

### Precise cross-node clock comparison

Source: https://docs.rustfs.com/en/installation/linux/prerequisites-and-service

For a more precise comparison, install sshpass and run this loop to get nanosecond timestamps from each node. The difference between any two nodes should be under 1 millisecond in a well-configured environment.

```bash
for host in node1 node2 node3 node4; do
  echo -n "$host: "
  ssh "$host" date -u '+%Y-%m-%d %H:%M:%S.%N'
done
```

--------------------------------

### Install AWS SDK for Go v2 modules

Source: https://docs.rustfs.com/en/developer/sdk/go

Commands to initialize a Go module and install the required AWS SDK packages for S3 operations.

```bash
go mod init rustfs-go-demo
go get github.com/aws/aws-sdk-go-v2/aws
go get github.com/aws/aws-sdk-go-v2/credentials
go get github.com/aws/aws-sdk-go-v2/service/s3
```

--------------------------------

### Set up Python environment and install pymilvus 2.6.0

Source: https://docs.rustfs.com/en/developer/integration/big-data/milvus

Creates a Python virtual environment and installs the Milvus client version 2.6.0 that matches the server release.

```bash
python3 -m venv .venv
source .venv/bin/activate
python -m pip install "pymilvus==2.6.0"
```

--------------------------------

### Set environment variables and create bucket with AWS CLI

Source: https://docs.rustfs.com/en/administration/data/s3-tables

Sets the endpoint and AWS credentials for the example clients, then creates the dedicated bucket `my-bucket` with the AWS CLI. Keep the same shell environment for the following requests and the PyIceberg guide.

```bash
export RUSTFS_ENDPOINT="http://localhost:9000"
export AWS_ACCESS_KEY_ID="<your-access-key>"
export AWS_SECRET_ACCESS_KEY="<your-secret-key>"
export AWS_DEFAULT_REGION="us-east-1"
```

```bash
aws --endpoint-url "$RUSTFS_ENDPOINT" s3api create-bucket --bucket my-bucket
```

--------------------------------

### rc CLI commands for cluster lifecycle operations

Source: https://docs.rustfs.com/en/operations/cluster-lifecycle

Common rc commands for alias setup, health checks, pool management, rebalance, decommission, and heal operations. Use `rc admin <group> --help` for the installed version.

```bash
rc alias set local http://localhost:9000 <your-access-key> <your-secret-key>
rc ping local
rc ready local --timeout 2
rc admin info cluster local
rc admin info disk local --offline
rc admin pool list local
rc admin pool status local 0 --by-id
rc admin rebalance start local
rc admin rebalance status local
rc admin rebalance stop local
rc admin decommission start local '/data/pool1/disk{1...4}'
rc admin decommission status local 1 --by-id
rc admin decommission cancel local 1 --by-id
rc admin decommission clear local 1 --by-id
rc admin heal start local --scan-mode deep
rc admin heal start local --bucket logs --prefix 2026/ --scan-mode deep
rc admin heal status local --client-token <TOKEN_FROM_START>
rc admin heal stop local --client-token <TOKEN_FROM_START>
```

--------------------------------

### Create bucket and enable versioning

Source: https://docs.rustfs.com/en/administration/data/object/versioning

Creates a bucket and enables versioning, then verifies the versioning status.

```bash
rc bucket create rustfs/my-bucket
rc bucket version enable rustfs/my-bucket
rc bucket version info rustfs/my-bucket
```

--------------------------------

### Create source bucket

Source: https://docs.rustfs.com/en/administration/data/bucket/replication

Create the source bucket.

```bash
rc bucket create source/my-bucket
```

--------------------------------

### Read-only admin check endpoints

Source: https://docs.rustfs.com/en/operations/cluster-lifecycle

List of GET endpoints for read-only admin checks after cluster start. The pool parameter is a pool command line or a zero-based index with by-id=true. Status queries ignore unknown parameters; mutation queries reject unknown or duplicate parameters and a by-id value other than true or false.

```text
GET /rustfs/admin/v3/pools/list
GET /rustfs/admin/v3/pools/status?pool=<pool>[&by-id=true]
GET /rustfs/admin/v3/decommission/status[?pool=<pool>&by-id=true]
GET /rustfs/admin/v4/cluster/snapshot
GET /rustfs/admin/v4/runtime/capabilities
```

--------------------------------

### Apply and verify Tenant

Source: https://docs.rustfs.com/en/installation/cloud-native/operator/tenant

Applies the Tenant manifest and verifies the created resources. Use 'get' to list the tenant, pods, PVCs, and services, and 'describe' to inspect the tenant details.

```bash
kubectl apply -f tenant.yaml
kubectl -n storage-a get tenant,pods,pvc,svc
kubectl -n storage-a describe tenant tenant-a
```

--------------------------------

### Install rclone

Source: https://docs.rustfs.com/en/developer/examples/rclone

Installs rclone using the official installation script. Requires sudo privileges.

```bash
curl https://rclone.org/install.sh | sudo bash
```

--------------------------------

### Create and read a table (example.py)

Source: https://docs.rustfs.com/en/developer/integration/big-data/pyiceberg

Sets up the namespace `analytics` and table `events` with a schema containing `id` and `payload` fields, plus the expected data rows. Update `identifier` in this file and the inspection/removal commands if you use different names. Names must be 1–64 ASCII characters (lowercase letters, digits, `_`, or `-`, with a letter or digit at each end); the full namespace is limited to 512 characters.

```python
import json

import pyarrow as pa

from rustfs_catalog import catalog

identifier = ("analytics", "events")
schema = pa.schema(
    [
        pa.field("id", pa.int64(), nullable=False),
        pa.field("payload", pa.string(), nullable=False),
    ]
)
expected = [{"id": 1, "payload": "alpha"}, {"id": 2, "payload": "beta"}]
```

--------------------------------

### Create demo resources and backup

Source: https://docs.rustfs.com/en/developer/integration/backup/velero

Creates demo resources and backs up the default namespace scope. The backup uploads resource archives and logs to RustFS.

```bash
kubectl create configmap demo-cm --from-literal=key=rustfs-velero-demo
kubectl create deployment nginx --image=nginx:1.27

velero backup create demo-backup --wait
velero backup get
```

--------------------------------

### GET /health

Source: https://docs.rustfs.com/en/operations/status-check

Liveness probe that returns 200 as long as the process is up. Also available via HEAD /health, GET /health/live, and GET /minio/health/live.

```APIDOC
## GET /health

### Description
Liveness probe that returns 200 as long as the process is up. Also available via HEAD /health, GET /health/live, and GET /minio/health/live.

### Method
GET

### Endpoint
/health

### Response
#### Success Response (200)
- **ready** (boolean) - Indicates the process is up.

#### Response Example
{
  "ready": true
}
```

--------------------------------

### Install rc on macOS (Intel and Apple silicon)

Source: https://docs.rustfs.com/en/operations/rc

Install the rc CLI on macOS. Choose the tab matching your architecture: Intel for x86_64 Macs, Apple silicon for arm64 Macs. Alternatively, install via Homebrew with 'brew install rustfs/tap/rc'.

```bash
curl -fLO https://github.com/rustfs/cli/releases/download/v0.1.30/rustfs-cli-macos-amd64-v0.1.30.tar.gz
tar -xzf rustfs-cli-macos-amd64-v0.1.30.tar.gz
sudo install -m 0755 rc /usr/local/bin/rc
```

```bash
curl -fLO https://github.com/rustfs/cli/releases/download/v0.1.30/rustfs-cli-macos-arm64-v0.1.30.tar.gz
tar -xzf rustfs-cli-macos-arm64-v0.1.30.tar.gz
sudo install -m 0755 rc /usr/local/bin/rc
```

--------------------------------

### Start collector and produce logs

Source: https://docs.rustfs.com/en/developer/integration/observability/opentelemetry

Creates the log file, starts the Docker Compose stack, and appends a second line. The collector tails the file from the beginning and uploads each buffer when the partition rolls over, so allow about a minute after the last line before checking.

```bash
echo "otel demo log line one" > app.log
docker compose up -d
echo "second line after start" >> app.log
```

--------------------------------

### Create and list buckets with rc

Source: https://docs.rustfs.com/en/administration/data/bucket/creation

Use the rc CLI to create a bucket and list existing buckets. The output confirms successful creation.

```bash
rc bucket create rustfs/my-bucket
rc bucket list rustfs/
```

```text
✓ Bucket 'rustfs/my-bucket' created successfully.
```

--------------------------------

### Install ntpd

Source: https://docs.rustfs.com/en/installation/linux/prerequisites-and-service

Install the legacy ntpd package on RHEL/CentOS/Rocky Linux or Ubuntu/Debian.

```bash
# RHEL / CentOS / Rocky Linux
sudo dnf install ntp -y

# Ubuntu / Debian
sudo apt install ntp -y
```

--------------------------------

### Quick install with custom credentials and storage sizes

Source: https://docs.rustfs.com/en/installation/cloud-native

Install RustFS into a dedicated namespace with custom access/secret keys and storage sizes. The chart fails rendering unless credentials are set or an existing secret is provided.

```bash
helm install rustfs . \
  --namespace rustfs --create-namespace \
  --set secret.rustfs.access_key=<your-access-key> \
  --set secret.rustfs.secret_key=<your-secret-key> \
  --set storageclass.dataStorageSize=100Gi \
  --set storageclass.logStorageSize=1Gi
```

--------------------------------

### Run the example script

Source: https://docs.rustfs.com/en/developer/integration/big-data/pyiceberg

Runs the Python script that creates and verifies the table. The output shows the rows and the metadata S3 URI.

```bash
python example.py
```

--------------------------------

### Install capo-s3

Source: https://docs.rustfs.com/en/developer/integration/others/capo

Install the capo-s3 package. Requires Python 3.10 or later.

```bash
pip install capo-s3
```

--------------------------------

### Create project files for RustFS-OpenObserve integration

Source: https://docs.rustfs.com/en/developer/integration/observability/openobserve

Create the project directory, define environment variables for RustFS and OpenObserve, and provide the Compose file that runs RustFS, an init-bucket job, and OpenObserve. The .env file uses sample credentials; OpenObserve v1.0.x requires a password of 8-128 characters with uppercase, lowercase, digit, and special characters. The Compose file sets ZO_LOCAL_MODE_STORAGE=s3 to force S3 storage and uses the rc image to create the bucket once RustFS is healthy.

```bash
mkdir rustfs-openobserve
cd rustfs-openobserve
```

```ini
RUSTFS_ACCESS_KEY=<your-access-key>
RUSTFS_SECRET_KEY=<your-secret-key>
RUSTFS_BUCKET_NAME=my-bucket
ZO_ROOT_USER_EMAIL=root@example.com
ZO_ROOT_USER_PASSWORD=Complexpass#123
```

```yaml
services:
  rustfs:
    image: rustfs/rustfs-x86-musl:v2.3.1
    environment:
      RUSTFS_ACCESS_KEY: ${RUSTFS_ACCESS_KEY}
      RUSTFS_SECRET_KEY: ${RUSTFS_SECRET_KEY}
      RUSTFS_VOLUMES: /data
      RUSTFS_ADDRESS: ":9000"
      RUSTFS_CONSOLE_ADDRESS: ":9001"
      RUSTFS_CONSOLE_ENABLE: "true"
    volumes:
      - rustfs-data:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://127.0.0.1:9000/health"]
      interval: 10s
      timeout: 5s
      retries: 6
      start_period: 10s
    networks:
      - observability

  init-bucket:
    image: rustfs/rc:latest
    depends_on:
      rustfs:
        condition: service_healthy
    environment:
      RUSTFS_ACCESS_KEY: ${RUSTFS_ACCESS_KEY}
      RUSTFS_SECRET_KEY: ${RUSTFS_SECRET_KEY}
    entrypoint:
      - /bin/sh
      - -c
      - |
        until /usr/bin/rc alias set rustfs http://rustfs:9000 "$${RUSTFS_ACCESS_KEY}" "$${RUSTFS_SECRET_KEY}"; do
          echo "Waiting for RustFS..."
          sleep 2
        done
        /usr/bin/rc ls rustfs/my-bucket >/dev/null 2>&1 || /usr/bin/rc mb rustfs/my-bucket
    networks:
      - observability

  openobserve:
    image: openobserve/openobserve:v1.0.3
    depends_on:
      rustfs:
        condition: service_healthy
      init-bucket:
        condition: service_completed_successfully
    environment:
      ZO_ROOT_USER_EMAIL: ${ZO_ROOT_USER_EMAIL}
      ZO_ROOT_USER_PASSWORD: ${ZO_ROOT_USER_PASSWORD}
      ZO_LOCAL_MODE: "true"
      ZO_LOCAL_MODE_STORAGE: "s3"
      ZO_DATA_DIR: /data
      ZO_HTTP_PORT: "5080"
      RUST_LOG: INFO
      ZO_S3_PROVIDER: s3
      ZO_S3_SERVER_URL: http://rustfs:9000
      ZO_S3_REGION_NAME: us-east-1
      ZO_S3_ACCESS_KEY: ${RUSTFS_ACCESS_KEY}
      ZO_S3_SECRET_KEY: ${RUSTFS_SECRET_KEY}
      ZO_S3_BUCKET_NAME: ${RUSTFS_BUCKET_NAME}
      # Upload Parquet files after 60 seconds instead of the default 600.
      # Keep the default for production-like setups.
      ZO_MAX_FILE_RETENTION_TIME: "60"
    volumes:
      - oo-data:/data
    ports:
      - "5080:5080"
    networks:
      - observability

networks:
  observability:

volumes:
  rustfs-data:
  oo-data:
```
Tokens:
Raw