diff --git a/.docker/Dockerfile.devenv b/.docker/Dockerfile.devenv
deleted file mode 100644
index 97345985..00000000
--- a/.docker/Dockerfile.devenv
+++ /dev/null
@@ -1,27 +0,0 @@
-FROM ubuntu:22.04
-
-ENV LANG C.UTF-8
-
-RUN sed -i s@http://.*archive.ubuntu.com@http://repo.huaweicloud.com@g /etc/apt/sources.list
-
-RUN apt-get clean && apt-get update && apt-get install wget git curl unzip gcc pkg-config libssl-dev lld libdbus-1-dev libwayland-dev libwebkit2gtk-4.1-dev libxdo-dev -y
-
-# install protoc
-RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
-    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
-    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
-    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
-
-# install flatc
-RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
-    && unzip Linux.flatc.binary.g++-13.zip \
-    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
-
-# install rust
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-
-COPY .docker/cargo.config.toml /root/.cargo/config.toml
-
-WORKDIR /root/s3-rustfs
-
-CMD [ "bash", "-c", "while true; do sleep 1; done" ]
diff --git a/.docker/Dockerfile.rockylinux9.3 b/.docker/Dockerfile.rockylinux9.3
deleted file mode 100644
index 8487a97b..00000000
--- a/.docker/Dockerfile.rockylinux9.3
+++ /dev/null
@@ -1,32 +0,0 @@
-FROM rockylinux:9.3 AS builder
-
-ENV LANG C.UTF-8
-
-RUN sed -e 's|^mirrorlist=|#mirrorlist=|g' \
-    -e 's|^#baseurl=http://dl.rockylinux.org/$contentdir|baseurl=https://mirrors.ustc.edu.cn/rocky|g' \
-    -i.bak \
-    /etc/yum.repos.d/rocky-extras.repo \
-    /etc/yum.repos.d/rocky.repo
-
-RUN dnf makecache
-
-RUN yum install wget git unzip gcc openssl-devel pkgconf-pkg-config -y
-
-# install protoc
-RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
-    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
-    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
-    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
-
-# install flatc
-RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
-    && unzip Linux.flatc.binary.g++-13.zip \
-    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc \
-    && rm -rf Linux.flatc.binary.g++-13.zip
-
-# install rust
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-
-COPY .docker/cargo.config.toml /root/.cargo/config.toml
-
-WORKDIR /root/s3-rustfs
diff --git a/.docker/Dockerfile.ubuntu22.04 b/.docker/Dockerfile.ubuntu22.04
deleted file mode 100644
index 8670aa45..00000000
--- a/.docker/Dockerfile.ubuntu22.04
+++ /dev/null
@@ -1,25 +0,0 @@
-FROM ubuntu:22.04
-
-ENV LANG C.UTF-8
-
-RUN sed -i s@http://.*archive.ubuntu.com@http://repo.huaweicloud.com@g /etc/apt/sources.list
-
-RUN apt-get clean && apt-get update && apt-get install wget git curl unzip gcc pkg-config libssl-dev lld libdbus-1-dev libwayland-dev libwebkit2gtk-4.1-dev libxdo-dev -y
-
-# install protoc
-RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
-    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
-    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
-    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
-
-# install flatc
-RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
-    && unzip Linux.flatc.binary.g++-13.zip \
-    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
-
-# install rust
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-
-COPY .docker/cargo.config.toml /root/.cargo/config.toml
-
-WORKDIR /root/s3-rustfs
diff --git a/.docker/README.md b/.docker/README.md
new file mode 100644
index 00000000..db312db4
--- /dev/null
+++ b/.docker/README.md
@@ -0,0 +1,157 @@
+# RustFS Docker Images
+
+This directory contains organized Dockerfile configurations for building RustFS container images across multiple platforms and system versions.
+
+## 📁 Directory Structure
+
+```
+.docker/
+├── alpine/                    # Alpine Linux variants
+│   ├── Dockerfile.prebuild    # Alpine + pre-built binaries
+│   └── Dockerfile.source      # Alpine + source compilation
+├── ubuntu/                    # Ubuntu variants
+│   ├── Dockerfile.prebuild    # Ubuntu + pre-built binaries
+│   ├── Dockerfile.source      # Ubuntu + source compilation
+│   └── Dockerfile.dev         # Ubuntu + development environment
+└── cargo.config.toml         # Rust cargo configuration
+```
+
+## 🎯 Image Variants
+
+### Production Images
+
+| Variant | Base OS | Build Method | Size | Use Case |
+|---------|---------|--------------|------|----------|
+| `production` (default) | Alpine 3.18 | Pre-built | Smallest | Production deployment |
+| `alpine` | Alpine 3.18 | Pre-built | Small | Explicit Alpine choice |
+| `alpine-source` | Alpine 3.18 | Source build | Small | Custom Alpine builds |
+| `ubuntu` | Ubuntu 22.04 | Pre-built | Medium | Ubuntu environments |
+| `ubuntu-source` | Ubuntu 22.04 | Source build | Medium | Full Ubuntu compatibility |
+
+### Development Images
+
+| Variant | Base OS | Features | Use Case |
+|---------|---------|----------|----------|
+| `ubuntu-dev` | Ubuntu 22.04 | Full toolchain + dev tools | Interactive development |
+
+## 🚀 Usage Examples
+
+### Quick Start (Production)
+
+```bash
+# Default production image (Alpine + pre-built)
+docker run -p 9000:9000 rustfs/rustfs:latest
+
+# Specific version with production variant
+docker run -p 9000:9000 rustfs/rustfs:1.2.3-production
+
+# Explicit Alpine variant
+docker run -p 9000:9000 rustfs/rustfs:latest-alpine
+
+# Ubuntu-based production
+docker run -p 9000:9000 rustfs/rustfs:latest-ubuntu
+```
+
+### Complete Tag Strategy Examples
+
+```bash
+# Stable Releases
+docker run rustfs/rustfs:1.2.3                # Main version (production)
+docker run rustfs/rustfs:1.2.3-production     # Explicit production variant
+docker run rustfs/rustfs:1.2.3-alpine         # Explicit Alpine variant
+docker run rustfs/rustfs:1.2.3-alpine-source  # Alpine source build
+docker run rustfs/rustfs:latest               # Latest stable
+
+# Prerelease Versions
+docker run rustfs/rustfs:1.3.0-alpha.2        # Specific alpha version
+docker run rustfs/rustfs:1.3.0-alpha.2-alpine # Alpha with Alpine
+docker run rustfs/rustfs:alpha                # Latest alpha
+docker run rustfs/rustfs:beta                 # Latest beta
+docker run rustfs/rustfs:rc                   # Latest release candidate
+
+# Development Versions
+docker run rustfs/rustfs:dev                  # Latest development
+docker run rustfs/rustfs:dev-13e4a0b          # Specific commit
+docker run rustfs/rustfs:dev-alpine           # Development Alpine
+```
+
+### Development Environment
+
+```bash
+# Start development container
+docker run -it -v $(pwd):/app -p 9000:9000 rustfs/rustfs:latest-ubuntu-dev
+
+# Inside container:
+cd /app
+cargo build --release
+cargo run
+```
+
+## 🏗️ Build Arguments
+
+All images support dynamic version selection:
+
+```bash
+# Build with specific version
+docker build \
+  --build-arg VERSION="1.0.0" \
+  --build-arg BUILD_TYPE="release" \
+  -f .docker/alpine/Dockerfile.prebuild \
+  -t rustfs:1.0.0-alpine .
+```
+
+## 🌐 Multi-Platform Support
+
+All images support multiple architectures:
+
+- `linux/amd64` (Intel/AMD 64-bit)
+- `linux/arm64` (ARM 64-bit, Apple Silicon, etc.)
+
+## ⚡ Build Speed Optimizations
+
+### Docker Build Optimizations
+
+- **Multi-layer caching**: GitHub Actions cache + Registry cache
+- **Parallel matrix builds**: All 5 variants build simultaneously
+- **Multi-platform builds**: amd64/arm64 built in parallel
+- **BuildKit features**: Advanced caching and inline cache
+
+### Rust Compilation Optimizations
+
+- **sccache**: Distributed compilation cache for Rust builds
+- **Parallel compilation**: Uses all available CPU cores (`-j $(nproc)`)
+- **Optimized cargo config**: Sparse registry protocol, fast linker (lld)
+- **Dependency caching**: Separate Docker layers for dependencies vs. source code
+- **Release optimizations**: LTO, strip symbols, optimized codegen
+
+### Cache Strategy
+
+```yaml
+# GitHub Actions cache
+cache-from: type=gha,scope=docker-{variant}
+cache-to: type=gha,mode=max,scope=docker-{variant}
+
+# Registry cache (persistent across runs)
+cache-from: type=registry,ref=ghcr.io/rustfs/rustfs:buildcache-{variant}
+cache-to: type=registry,ref=ghcr.io/rustfs/rustfs:buildcache-{variant}
+```
+
+### Build Performance Comparison
+
+| Build Type | Time (Est.) | Cache Hit | Cache Miss |
+|------------|-------------|-----------|-----------|
+| Production (Alpine pre-built) | ~2-3 min | ~1 min | ~2 min |
+| Alpine pre-built | ~2-3 min | ~1 min | ~2 min |
+| Alpine source | ~8-12 min | ~3-5 min | ~10 min |
+| Ubuntu pre-built | ~3-4 min | ~1-2 min | ~3 min |
+| Ubuntu source | ~10-15 min | ~4-6 min | ~12 min |
+
+## 📋 Build Matrix
+
+| Trigger | Version Format | Download Path | Image Tags |
+|---------|---------------|---------------|------------|
+| `push main` | `dev-{sha}` | `artifacts/rustfs/dev/` | `dev-{sha}-{variant}`, `dev-{variant}`, `dev` |
+| `push 1.2.3` | `1.2.3` | `artifacts/rustfs/release/` | `1.2.3-{variant}`, `1.2.3`, `latest-{variant}`, `latest` |
+| `push 1.3.0-alpha.2` | `1.3.0-alpha.2` | `artifacts/rustfs/release/` | `1.3.0-alpha.2-{variant}`, `alpha-{variant}`, `alpha` |
+| `push 1.3.0-beta.1` | `1.3.0-beta.1` | `artifacts/rustfs/release/` | `1.3.0-beta.1-{variant}`, `beta-{variant}`, `beta` |
+| `push 1.3.0-rc.1` | `1.3.0-rc.1` | `artifacts/rustfs/release/` | `1.3.0-rc.1-{variant}`, `rc-{variant}`, `rc` |
diff --git a/.docker/alpine/Dockerfile.prebuild b/.docker/alpine/Dockerfile.prebuild
new file mode 100644
index 00000000..d694e80c
--- /dev/null
+++ b/.docker/alpine/Dockerfile.prebuild
@@ -0,0 +1,117 @@
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Multi-stage Alpine build for minimal runtime image
+FROM rust:1.88-alpine AS builder
+
+# Build arguments for dynamic artifact download
+ARG VERSION=""
+ARG BUILD_TYPE="release"
+ARG TARGETARCH
+
+# Install build dependencies
+RUN apk add --no-cache \
+    musl-dev \
+    pkgconfig \
+    openssl-dev \
+    openssl-libs-static \
+    curl \
+    unzip \
+    bash \
+    wget \
+    ca-certificates
+
+# Install protoc
+RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
+    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
+    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
+    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
+
+# Install flatc
+RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
+    && unzip Linux.flatc.binary.g++-13.zip \
+    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc \
+    && rm -rf Linux.flatc.binary.g++-13.zip
+
+# Option A: Download pre-built binary (faster)
+RUN if [ -n "$VERSION" ]; then \
+        # Map TARGETARCH to our naming convention
+        case "${TARGETARCH}" in \
+            amd64) ARCH="x86_64" ;; \
+            arm64) ARCH="aarch64" ;; \
+            *) echo "Unsupported architecture: ${TARGETARCH}" && exit 1 ;; \
+        esac; \
+        \
+        # Determine download path and filename
+        if [ "${BUILD_TYPE}" = "development" ]; then \
+            DOWNLOAD_PATH="artifacts/rustfs/dev"; \
+            FILENAME="rustfs-linux-${ARCH}-dev-${VERSION}.zip"; \
+        else \
+            DOWNLOAD_PATH="artifacts/rustfs/release"; \
+            FILENAME="rustfs-linux-${ARCH}-v${VERSION}.zip"; \
+        fi; \
+        \
+        # Download the binary
+        DOWNLOAD_URL="https://dl.rustfs.com/${DOWNLOAD_PATH}/${FILENAME}"; \
+        echo "Downloading RustFS binary from: ${DOWNLOAD_URL}"; \
+        curl -Lo /tmp/rustfs.zip "${DOWNLOAD_URL}"; \
+        unzip -o /tmp/rustfs.zip -d /tmp; \
+        mv /tmp/rustfs /usr/local/bin/rustfs; \
+        chmod +x /usr/local/bin/rustfs; \
+        rm -rf /tmp/*; \
+    else \
+        echo "No VERSION provided, will build from source"; \
+        echo "Source build not yet implemented in Alpine variant"; \
+        exit 1; \
+    fi
+
+# Final Alpine runtime image
+FROM alpine:3.18
+
+RUN apk add --no-cache \
+    ca-certificates \
+    tzdata \
+    bash
+
+# Create rustfs user for security
+RUN addgroup -g 1000 rustfs && \
+    adduser -D -u 1000 -G rustfs rustfs
+
+WORKDIR /app
+
+# Copy binary from builder
+COPY --from=builder /usr/local/bin/rustfs /app/rustfs
+RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs
+
+# Create data directories
+RUN mkdir -p /data && chown -R rustfs:rustfs /data /app
+
+# Switch to non-root user
+USER rustfs
+
+# Environment variables
+ENV RUSTFS_ACCESS_KEY=rustfsadmin \
+    RUSTFS_SECRET_KEY=rustfsadmin \
+    RUSTFS_ADDRESS=":9000" \
+    RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data \
+    RUST_LOG=warn
+
+EXPOSE 9000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
+
+CMD ["/app/rustfs"]
diff --git a/.docker/alpine/Dockerfile.source b/.docker/alpine/Dockerfile.source
new file mode 100644
index 00000000..6de7b802
--- /dev/null
+++ b/.docker/alpine/Dockerfile.source
@@ -0,0 +1,126 @@
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Multi-stage Alpine build from source
+FROM rust:1.88-alpine AS builder
+
+# Install build dependencies
+RUN apk add --no-cache \
+    musl-dev \
+    pkgconfig \
+    openssl-dev \
+    openssl-libs-static \
+    curl \
+    unzip \
+    bash \
+    wget \
+    ca-certificates \
+    git
+
+# Install sccache for Rust compilation caching
+RUN wget https://github.com/mozilla/sccache/releases/download/v0.8.1/sccache-v0.8.1-x86_64-unknown-linux-musl.tar.gz \
+    && tar -xzf sccache-v0.8.1-x86_64-unknown-linux-musl.tar.gz \
+    && mv sccache-v0.8.1-x86_64-unknown-linux-musl/sccache /usr/local/bin/ \
+    && chmod +x /usr/local/bin/sccache \
+    && rm -rf sccache-v0.8.1-x86_64-unknown-linux-musl.tar.gz sccache-v0.8.1-x86_64-unknown-linux-musl
+
+# Set up sccache environment
+ENV RUSTC_WRAPPER=sccache \
+    SCCACHE_DIR=/tmp/sccache \
+    SCCACHE_CACHE_SIZE=2G
+
+# Install protoc
+RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
+    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
+    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
+    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
+
+# Install flatc
+RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
+    && unzip Linux.flatc.binary.g++-13.zip \
+    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc \
+    && rm -rf Linux.flatc.binary.g++-13.zip
+
+WORKDIR /usr/src/rustfs
+
+# Copy cargo configuration for optimized builds
+COPY .docker/cargo.config.toml ./.cargo/config.toml
+
+# Copy cargo files for dependency caching
+COPY Cargo.toml Cargo.lock ./
+COPY */Cargo.toml ./*/
+
+# Create dummy main.rs files for dependency compilation
+RUN find . -name "Cargo.toml" -not -path "./Cargo.toml" | \
+    xargs -I {} dirname {} | \
+    xargs -I {} sh -c 'mkdir -p {}/src && echo "fn main() {}" > {}/src/main.rs'
+
+# Configure cargo for optimized builds
+ENV CARGO_NET_GIT_FETCH_WITH_CLI=true \
+    CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse \
+    CARGO_INCREMENTAL=0 \
+    CARGO_PROFILE_RELEASE_DEBUG=false \
+    CARGO_PROFILE_RELEASE_SPLIT_DEBUGINFO=off \
+    CARGO_PROFILE_RELEASE_STRIP=symbols
+
+# Build dependencies only (cache layer) with optimizations
+RUN cargo build --release --target x86_64-unknown-linux-musl -j $(nproc)
+
+# Copy source code
+COPY . .
+
+# Build the actual application with optimizations
+RUN sccache --start-server 2>/dev/null || true && \
+    cargo build --release --target x86_64-unknown-linux-musl --bin rustfs -j $(nproc) && \
+    sccache --show-stats || true
+
+# Final Alpine runtime image
+FROM alpine:3.18
+
+RUN apk add --no-cache \
+    ca-certificates \
+    tzdata \
+    bash
+
+# Create rustfs user for security
+RUN addgroup -g 1000 rustfs && \
+    adduser -D -u 1000 -G rustfs rustfs
+
+WORKDIR /app
+
+# Copy binary from builder
+COPY --from=builder /usr/src/rustfs/target/x86_64-unknown-linux-musl/release/rustfs /app/rustfs
+RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs
+
+# Create data directories
+RUN mkdir -p /data && chown -R rustfs:rustfs /data /app
+
+# Switch to non-root user
+USER rustfs
+
+# Environment variables
+ENV RUSTFS_ACCESS_KEY=rustfsadmin \
+    RUSTFS_SECRET_KEY=rustfsadmin \
+    RUSTFS_ADDRESS=":9000" \
+    RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data \
+    RUST_LOG=warn
+
+EXPOSE 9000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
+
+CMD ["/app/rustfs"]
diff --git a/.docker/cargo.config.toml b/.docker/cargo.config.toml
index 74debc4e..87ffdf83 100644
--- a/.docker/cargo.config.toml
+++ b/.docker/cargo.config.toml
@@ -12,8 +12,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# Build optimization settings
+[build]
+# Use all available CPU cores for parallel compilation
+jobs = 0  # 0 = use all cores
+
+[target.x86_64-unknown-linux-musl]
+# Use lld linker for faster linking
+linker = "lld"
+
+[target.x86_64-unknown-linux-gnu]
+# Use lld linker for faster linking
+linker = "lld"
+
+[target.aarch64-unknown-linux-gnu]
+# Use lld linker for faster linking
+linker = "lld"
+
+[profile.release]
+# Optimize for size and speed
+codegen-units = 1
+lto = true
+panic = "abort"
+strip = true
+debug = false
+
+[profile.dev]
+# Faster incremental builds during development
+incremental = true
+debug = true
+
+[registry]
+# Use sparse registry protocol for faster dependency resolution
+default = "sparse+https://index.crates.io/"
+
 [source.crates-io]
-registry = "https://github.com/rust-lang/crates.io-index"
+# Use sparse registry protocol
+replace-with = "sparse+https://index.crates.io/"
 
 [net]
+# Use git CLI for better performance with private repos
 git-fetch-with-cli = true
diff --git a/.docker/compose/README.md b/.docker/compose/README.md
new file mode 100644
index 00000000..b52267b5
--- /dev/null
+++ b/.docker/compose/README.md
@@ -0,0 +1,80 @@
+# Docker Compose Configurations
+
+This directory contains specialized Docker Compose configurations for different use cases.
+
+## 📁 Configuration Files
+
+This directory contains specialized Docker Compose configurations and their associated Dockerfiles, keeping related files organized together.
+
+### Main Configuration (Root Directory)
+
+- **`../../docker-compose.yml`** - **Default Production Setup**
+  - Complete production-ready configuration
+  - Includes RustFS server + full observability stack
+  - Supports multiple profiles: `dev`, `observability`, `cache`, `proxy`
+  - Recommended for most users
+
+### Specialized Configurations
+
+- **`docker-compose.cluster.yaml`** - **Distributed Testing**
+  - 4-node cluster setup for testing distributed storage
+  - Uses local compiled binaries
+  - Simulates multi-node environment
+  - Ideal for development and cluster testing
+
+- **`docker-compose.observability.yaml`** - **Observability Focus**
+  - Specialized setup for testing observability features
+  - Includes OpenTelemetry, Jaeger, Prometheus, Loki, Grafana
+  - Uses `../../Dockerfile.obs` for builds
+  - Perfect for observability development
+
+## 🚀 Usage Examples
+
+### Production Setup
+
+```bash
+# Start main service
+docker-compose up -d
+
+# Start with development profile
+docker-compose --profile dev up -d
+
+# Start with full observability
+docker-compose --profile observability up -d
+```
+
+### Cluster Testing
+
+```bash
+# Build and start 4-node cluster (run from project root)
+cd .docker/compose
+docker-compose -f docker-compose.cluster.yaml up -d
+
+# Or run directly from project root
+docker-compose -f .docker/compose/docker-compose.cluster.yaml up -d
+```
+
+### Observability Testing
+
+```bash
+# Start observability-focused environment (run from project root)
+cd .docker/compose
+docker-compose -f docker-compose.observability.yaml up -d
+
+# Or run directly from project root
+docker-compose -f .docker/compose/docker-compose.observability.yaml up -d
+```
+
+## 🔧 Configuration Overview
+
+| Configuration | Nodes | Storage | Observability | Use Case |
+|---------------|-------|---------|---------------|----------|
+| **Main** | 1 | Volume mounts | Full stack | Production |
+| **Cluster** | 4 | HTTP endpoints | Basic | Testing |
+| **Observability** | 4 | Local data | Advanced | Development |
+
+## 📝 Notes
+
+- Always ensure you have built the required binaries before starting cluster tests
+- The main configuration is sufficient for most use cases
+- Specialized configurations are for specific testing scenarios
diff --git a/docker-compose.yaml b/.docker/compose/docker-compose.cluster.yaml
similarity index 64%
rename from docker-compose.yaml
rename to .docker/compose/docker-compose.cluster.yaml
index 8de2ec71..135997c8 100644
--- a/docker-compose.yaml
+++ b/.docker/compose/docker-compose.cluster.yaml
@@ -14,18 +14,20 @@
 
 services:
   node0:
-    image: rustfs/rustfs:latest  # Replace with your image name and label
+    image: rustfs/rustfs:latest # Replace with your image name and label
     container_name: node0
     hostname: node0
     environment:
       - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
       - RUSTFS_ADDRESS=0.0.0.0:9000
       - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_ACCESS_KEY=rustfsadmin
+      - RUSTFS_SECRET_KEY=rustfsadmin
     platform: linux/amd64
     ports:
-      - "9000:9000"  # Map port 9001 of the host to port 9000 of the container
+      - "9000:9000" # Map port 9001 of the host to port 9000 of the container
     volumes:
-      - ./target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
+      - ../../target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
     command: "/app/rustfs"
 
   node1:
@@ -36,11 +38,13 @@ services:
       - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
       - RUSTFS_ADDRESS=0.0.0.0:9000
       - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_ACCESS_KEY=rustfsadmin
+      - RUSTFS_SECRET_KEY=rustfsadmin
     platform: linux/amd64
     ports:
-      - "9001:9000"  # Map port 9002 of the host to port 9000 of the container
+      - "9001:9000" # Map port 9002 of the host to port 9000 of the container
     volumes:
-      - ./target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
+      - ../../target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
     command: "/app/rustfs"
 
   node2:
@@ -51,11 +55,13 @@ services:
       - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
       - RUSTFS_ADDRESS=0.0.0.0:9000
       - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_ACCESS_KEY=rustfsadmin
+      - RUSTFS_SECRET_KEY=rustfsadmin
     platform: linux/amd64
     ports:
-      - "9002:9000"  # Map port 9003 of the host to port 9000 of the container
+      - "9002:9000" # Map port 9003 of the host to port 9000 of the container
     volumes:
-      - ./target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
+      - ../../target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
     command: "/app/rustfs"
 
   node3:
@@ -66,9 +72,11 @@ services:
       - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
       - RUSTFS_ADDRESS=0.0.0.0:9000
       - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_ACCESS_KEY=rustfsadmin
+      - RUSTFS_SECRET_KEY=rustfsadmin
     platform: linux/amd64
     ports:
-      - "9003:9000"  # Map port 9004 of the host to port 9000 of the container
+      - "9003:9000" # Map port 9004 of the host to port 9000 of the container
     volumes:
-      - ./target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
+      - ../../target/x86_64-unknown-linux-musl/release/rustfs:/app/rustfs
     command: "/app/rustfs"
diff --git a/docker-compose-obs.yaml b/.docker/compose/docker-compose.observability.yaml
similarity index 83%
rename from docker-compose-obs.yaml
rename to .docker/compose/docker-compose.observability.yaml
index e6c4ac21..d0ff4299 100644
--- a/docker-compose-obs.yaml
+++ b/.docker/compose/docker-compose.observability.yaml
@@ -18,7 +18,7 @@ services:
     environment:
       - TZ=Asia/Shanghai
     volumes:
-      - ./.docker/observability/otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml
+      - ../../.docker/observability/otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml
     ports:
       - 1888:1888
       - 8888:8888
@@ -44,7 +44,7 @@ services:
     environment:
       - TZ=Asia/Shanghai
     volumes:
-      - ./.docker/observability/prometheus.yml:/etc/prometheus/prometheus.yml
+      - ../../.docker/observability/prometheus.yml:/etc/prometheus/prometheus.yml
     ports:
       - "9090:9090"
     networks:
@@ -54,7 +54,7 @@ services:
     environment:
       - TZ=Asia/Shanghai
     volumes:
-      - ./.docker/observability/loki-config.yaml:/etc/loki/local-config.yaml
+      - ../../.docker/observability/loki-config.yaml:/etc/loki/local-config.yaml
     ports:
       - "3100:3100"
     command: -config.file=/etc/loki/local-config.yaml
@@ -63,7 +63,7 @@ services:
   grafana:
     image: grafana/grafana:12.0.2
     ports:
-      - "3000:3000"  # Web UI
+      - "3000:3000" # Web UI
     environment:
       - GF_SECURITY_ADMIN_PASSWORD=admin
       - TZ=Asia/Shanghai
@@ -72,7 +72,7 @@ services:
 
   node1:
     build:
-      context: .
+      context: ../..
       dockerfile: Dockerfile.obs
     container_name: node1
     environment:
@@ -83,13 +83,13 @@ services:
       - RUSTFS_OBS_LOGGER_LEVEL=debug
     platform: linux/amd64
     ports:
-      - "9001:9000"  # Map port 9001 of the host to port 9000 of the container
+      - "9001:9000" # Map port 9001 of the host to port 9000 of the container
     networks:
       - rustfs-network
 
   node2:
     build:
-      context: .
+      context: ../..
       dockerfile: Dockerfile.obs
     container_name: node2
     environment:
@@ -100,13 +100,13 @@ services:
       - RUSTFS_OBS_LOGGER_LEVEL=debug
     platform: linux/amd64
     ports:
-      - "9002:9000"  # Map port 9002 of the host to port 9000 of the container
+      - "9002:9000" # Map port 9002 of the host to port 9000 of the container
     networks:
       - rustfs-network
 
   node3:
     build:
-      context: .
+      context: ../..
       dockerfile: Dockerfile.obs
     container_name: node3
     environment:
@@ -117,13 +117,13 @@ services:
       - RUSTFS_OBS_LOGGER_LEVEL=debug
     platform: linux/amd64
     ports:
-      - "9003:9000"  # Map port 9003 of the host to port 9000 of the container
+      - "9003:9000" # Map port 9003 of the host to port 9000 of the container
     networks:
       - rustfs-network
 
   node4:
     build:
-      context: .
+      context: ../..
       dockerfile: Dockerfile.obs
     container_name: node4
     environment:
@@ -134,7 +134,7 @@ services:
       - RUSTFS_OBS_LOGGER_LEVEL=debug
     platform: linux/amd64
     ports:
-      - "9004:9000"  # Map port 9004 of the host to port 9000 of the container
+      - "9004:9000" # Map port 9004 of the host to port 9000 of the container
     networks:
       - rustfs-network
 
diff --git a/.docker/ubuntu/Dockerfile.dev b/.docker/ubuntu/Dockerfile.dev
new file mode 100644
index 00000000..a79216fc
--- /dev/null
+++ b/.docker/ubuntu/Dockerfile.dev
@@ -0,0 +1,96 @@
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Ubuntu-based development environment
+# Provides full development toolchain for building RustFS from source
+FROM ubuntu:22.04
+
+ENV LANG=C.UTF-8
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Use faster mirrors for better build performance
+RUN sed -i s@http://.*archive.ubuntu.com@http://repo.huaweicloud.com@g /etc/apt/sources.list
+
+# Install development dependencies
+RUN apt-get clean && apt-get update && apt-get install -y \
+    wget \
+    git \
+    curl \
+    unzip \
+    gcc \
+    pkg-config \
+    libssl-dev \
+    lld \
+    libdbus-1-dev \
+    libwayland-dev \
+    libwebkit2gtk-4.1-dev \
+    libxdo-dev \
+    ca-certificates \
+    bash \
+    vim \
+    nano \
+    htop \
+    tree \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install protoc
+RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
+    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
+    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
+    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
+
+# Install flatc
+RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
+    && unzip Linux.flatc.binary.g++-13.zip \
+    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
+
+# Install rust for development
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+# Install additional Rust tools for development
+RUN /root/.cargo/bin/cargo install \
+    cargo-watch \
+    cargo-nextest \
+    cargo-audit \
+    cargo-outdated
+
+# Copy cargo config for Chinese users
+COPY .docker/cargo.config.toml /root/.cargo/config.toml
+
+# Create development user
+RUN groupadd -g 1000 rustfs && \
+    useradd -d /app -g rustfs -u 1000 -s /bin/bash rustfs
+
+WORKDIR /app
+
+# Create data directories for testing
+RUN mkdir -p /data && chown -R rustfs:rustfs /data /app
+
+# Environment variables for development
+ENV RUSTFS_ACCESS_KEY=devadmin \
+    RUSTFS_SECRET_KEY=devadmin \
+    RUSTFS_ADDRESS=":9000" \
+    RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data \
+    RUST_LOG=debug \
+    RUST_BACKTRACE=1
+
+EXPOSE 9000
+
+# Development mode: keep container alive for interactive development
+CMD echo "RustFS Development Environment" && \
+    echo "Source code should be mounted at /app" && \
+    echo "Use 'cargo build' to build, 'cargo run' to run" && \
+    exec bash -c "while true; do sleep 1; done"
diff --git a/.docker/ubuntu/Dockerfile.prebuild b/.docker/ubuntu/Dockerfile.prebuild
new file mode 100644
index 00000000..f54af613
--- /dev/null
+++ b/.docker/ubuntu/Dockerfile.prebuild
@@ -0,0 +1,130 @@
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Multi-purpose Ubuntu-based Dockerfile
+# Can be used as development environment or ubuntu runtime variant
+FROM ubuntu:22.04
+
+# Build arguments for dynamic artifact download (when used as runtime)
+ARG VERSION=""
+ARG BUILD_TYPE="release"
+ARG TARGETARCH
+
+ENV LANG=C.UTF-8
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Use faster mirrors for better build performance
+RUN sed -i s@http://.*archive.ubuntu.com@http://repo.huaweicloud.com@g /etc/apt/sources.list
+
+# Install dependencies
+RUN apt-get clean && apt-get update && apt-get install -y \
+    wget \
+    git \
+    curl \
+    unzip \
+    gcc \
+    pkg-config \
+    libssl-dev \
+    lld \
+    libdbus-1-dev \
+    libwayland-dev \
+    libwebkit2gtk-4.1-dev \
+    libxdo-dev \
+    ca-certificates \
+    bash \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install protoc
+RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
+    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
+    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
+    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
+
+# Install flatc
+RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
+    && unzip Linux.flatc.binary.g++-13.zip \
+    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
+
+# Install rust (for development use)
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+# Copy cargo config for Chinese users
+COPY .docker/cargo.config.toml /root/.cargo/config.toml
+
+# If VERSION is provided, download pre-built binary (for runtime use)
+# Otherwise, this acts as a development environment
+RUN if [ -n "$VERSION" ]; then \
+        # Map TARGETARCH to our naming convention
+        case "${TARGETARCH}" in \
+            amd64) ARCH="x86_64" ;; \
+            arm64) ARCH="aarch64" ;; \
+            *) echo "Unsupported architecture: ${TARGETARCH}" && exit 1 ;; \
+        esac; \
+        \
+        # Determine download path and filename
+        if [ "${BUILD_TYPE}" = "development" ]; then \
+            DOWNLOAD_PATH="artifacts/rustfs/dev"; \
+            FILENAME="rustfs-linux-${ARCH}-dev-${VERSION}.zip"; \
+        else \
+            DOWNLOAD_PATH="artifacts/rustfs/release"; \
+            FILENAME="rustfs-linux-${ARCH}-v${VERSION}.zip"; \
+        fi; \
+        \
+        # Download the binary
+        DOWNLOAD_URL="https://dl.rustfs.com/${DOWNLOAD_PATH}/${FILENAME}"; \
+        echo "Downloading RustFS binary from: ${DOWNLOAD_URL}"; \
+        curl -Lo /tmp/rustfs.zip "${DOWNLOAD_URL}" || { \
+            echo "Failed to download, continuing as development environment"; \
+        }; \
+        if [ -f /tmp/rustfs.zip ]; then \
+            unzip -o /tmp/rustfs.zip -d /tmp; \
+            mv /tmp/rustfs /usr/local/bin/rustfs; \
+            chmod +x /usr/local/bin/rustfs; \
+            rm -rf /tmp/*; \
+        fi; \
+    fi
+
+# Create rustfs user for security
+RUN groupadd -g 1000 rustfs && \
+    useradd -d /app -g rustfs -u 1000 -s /bin/bash rustfs
+
+WORKDIR /app
+
+# Create data directories
+RUN mkdir -p /data && chown -R rustfs:rustfs /data /app
+
+# Environment variables
+ENV RUSTFS_ACCESS_KEY=rustfsadmin \
+    RUSTFS_SECRET_KEY=rustfsadmin \
+    RUSTFS_ADDRESS=":9000" \
+    RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data \
+    RUST_LOG=warn
+
+EXPOSE 9000
+
+# Health check (only if rustfs binary exists)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD if [ -f /usr/local/bin/rustfs ]; then wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1; else exit 0; fi
+
+# Default command: if rustfs binary exists, run it; otherwise, keep container alive for development
+CMD if [ -f /usr/local/bin/rustfs ]; then \
+        echo "Starting RustFS server..."; \
+        exec /usr/local/bin/rustfs; \
+    else \
+        echo "Running in development mode..."; \
+        echo "RustFS source code should be mounted at /app"; \
+        exec bash -c "while true; do sleep 1; done"; \
+    fi
diff --git a/Dockerfile.multi-stage b/.docker/ubuntu/Dockerfile.source
similarity index 68%
rename from Dockerfile.multi-stage
rename to .docker/ubuntu/Dockerfile.source
index 08d6d3d1..1bcc2f4c 100644
--- a/Dockerfile.multi-stage
+++ b/.docker/ubuntu/Dockerfile.source
@@ -4,7 +4,7 @@ ARG TARGETPLATFORM
 ARG BUILDPLATFORM
 
 # Build stage
-FROM --platform=$BUILDPLATFORM rust:1.85-bookworm AS builder
+FROM --platform=$BUILDPLATFORM rust:1.88-bookworm AS builder
 
 # Install required build dependencies
 RUN apt-get update && apt-get install -y \
@@ -18,6 +18,18 @@ RUN apt-get update && apt-get install -y \
     lld \
     && rm -rf /var/lib/apt/lists/*
 
+# Install sccache for Rust compilation caching
+RUN wget https://github.com/mozilla/sccache/releases/download/v0.8.1/sccache-v0.8.1-x86_64-unknown-linux-gnu.tar.gz \
+    && tar -xzf sccache-v0.8.1-x86_64-unknown-linux-gnu.tar.gz \
+    && mv sccache-v0.8.1-x86_64-unknown-linux-gnu/sccache /usr/local/bin/ \
+    && chmod +x /usr/local/bin/sccache \
+    && rm -rf sccache-v0.8.1-x86_64-unknown-linux-gnu.tar.gz sccache-v0.8.1-x86_64-unknown-linux-gnu
+
+# Set up sccache environment
+ENV RUSTC_WRAPPER=sccache \
+    SCCACHE_DIR=/tmp/sccache \
+    SCCACHE_CACHE_SIZE=2G
+
 # Install cross-compilation tools for ARM64
 RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
         apt-get update && \
@@ -50,6 +62,9 @@ ENV CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++
 
 WORKDIR /usr/src/rustfs
 
+# Copy cargo configuration for optimized builds
+COPY .docker/cargo.config.toml ./.cargo/config.toml
+
 # Copy Cargo files for dependency caching
 COPY Cargo.toml Cargo.lock ./
 COPY */Cargo.toml ./*/
@@ -59,10 +74,19 @@ RUN find . -name "Cargo.toml" -not -path "./Cargo.toml" | \
     xargs -I {} dirname {} | \
     xargs -I {} sh -c 'mkdir -p {}/src && echo "fn main() {}" > {}/src/main.rs'
 
-# Build dependencies only (cache layer)
-RUN case "$TARGETPLATFORM" in \
-        "linux/amd64") cargo build --release --target x86_64-unknown-linux-gnu ;; \
-        "linux/arm64") cargo build --release --target aarch64-unknown-linux-gnu ;; \
+# Configure cargo for optimized builds
+ENV CARGO_NET_GIT_FETCH_WITH_CLI=true \
+    CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse \
+    CARGO_INCREMENTAL=0 \
+    CARGO_PROFILE_RELEASE_DEBUG=false \
+    CARGO_PROFILE_RELEASE_SPLIT_DEBUGINFO=off \
+    CARGO_PROFILE_RELEASE_STRIP=symbols
+
+# Build dependencies only (cache layer) with optimizations
+RUN sccache --start-server 2>/dev/null || true && \
+    case "$TARGETPLATFORM" in \
+        "linux/amd64") cargo build --release --target x86_64-unknown-linux-gnu -j $(nproc) ;; \
+        "linux/arm64") cargo build --release --target aarch64-unknown-linux-gnu -j $(nproc) ;; \
     esac
 
 # Copy source code
@@ -71,17 +95,19 @@ COPY . .
 # Generate protobuf code
 RUN cargo run --bin gproto
 
-# Build the actual application
-RUN case "$TARGETPLATFORM" in \
+# Build the actual application with optimizations
+RUN sccache --start-server 2>/dev/null || true && \
+    case "$TARGETPLATFORM" in \
         "linux/amd64") \
-            cargo build --release --target x86_64-unknown-linux-gnu --bin rustfs && \
+            cargo build --release --target x86_64-unknown-linux-gnu --bin rustfs -j $(nproc) && \
             cp target/x86_64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
             ;; \
         "linux/arm64") \
-            cargo build --release --target aarch64-unknown-linux-gnu --bin rustfs && \
+            cargo build --release --target aarch64-unknown-linux-gnu --bin rustfs -j $(nproc) && \
             cp target/aarch64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
             ;; \
-    esac
+    esac && \
+    sccache --show-stats || true
 
 # Runtime stage - Ubuntu minimal for better compatibility
 FROM ubuntu:22.04
@@ -113,6 +139,14 @@ USER rustfs
 # Expose ports
 EXPOSE 9000
 
+# Environment variables
+ENV RUSTFS_ACCESS_KEY=rustfsadmin \
+    RUSTFS_SECRET_KEY=rustfsadmin \
+    RUSTFS_ADDRESS=":9000" \
+    RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data \
+    RUST_LOG=warn
+
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 8740284e..a8e90125 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -16,7 +16,7 @@ name: Build and Release
 
 on:
   push:
-    tags: ["*"]
+    tags: ["*.*.*"]
     branches: [main]
     paths-ignore:
       - "**.md"
@@ -65,39 +65,79 @@ env:
   CARGO_INCREMENTAL: 0
 
 jobs:
-  # Second layer: Business logic level checks (handling build strategy)
+  # Build strategy check - determine build type based on trigger
   build-check:
     name: Build Strategy Check
     runs-on: ubuntu-latest
     outputs:
       should_build: ${{ steps.check.outputs.should_build }}
       build_type: ${{ steps.check.outputs.build_type }}
+      version: ${{ steps.check.outputs.version }}
+      short_sha: ${{ steps.check.outputs.short_sha }}
+      is_prerelease: ${{ steps.check.outputs.is_prerelease }}
     steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
       - name: Determine build strategy
         id: check
         run: |
           should_build=false
           build_type="none"
+          version=""
+          short_sha=""
+          is_prerelease=false
 
-          # Business logic: when we need to build
-          if [[ "${{ github.event_name }}" == "schedule" ]] || \
-             [[ "${{ github.event_name }}" == "workflow_dispatch" ]] || \
-             [[ "${{ github.event.inputs.force_build }}" == "true" ]] || \
-             [[ "${{ contains(github.event.head_commit.message, '--build') }}" == "true" ]]; then
+          # Get short SHA for all builds
+          short_sha=$(git rev-parse --short HEAD)
+
+          # Determine build type based on trigger
+          if [[ "${{ startsWith(github.ref, 'refs/tags/') }}" == "true" ]]; then
+            # Tag push - release or prerelease
+            should_build=true
+            tag_name="${GITHUB_REF#refs/tags/}"
+            version="${tag_name}"
+
+            # Check if this is a prerelease
+            if [[ "$tag_name" == *"alpha"* ]] || [[ "$tag_name" == *"beta"* ]] || [[ "$tag_name" == *"rc"* ]]; then
+              build_type="prerelease"
+              is_prerelease=true
+              echo "🚀 Prerelease build detected: $tag_name"
+            else
+              build_type="release"
+              echo "📦 Release build detected: $tag_name"
+            fi
+          elif [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
+            # Main branch push - development build
             should_build=true
             build_type="development"
-          fi
-
-          # Always build for tag pushes (version releases)
-          if [[ "${{ startsWith(github.ref, 'refs/tags/') }}" == "true" ]]; then
+            version="dev-${short_sha}"
+            echo "🛠️  Development build detected"
+          elif [[ "${{ github.event_name }}" == "schedule" ]] || \
+               [[ "${{ github.event_name }}" == "workflow_dispatch" ]] || \
+               [[ "${{ github.event.inputs.force_build }}" == "true" ]] || \
+               [[ "${{ contains(github.event.head_commit.message, '--build') }}" == "true" ]]; then
+            # Scheduled or manual build
             should_build=true
-            build_type="release"
-            echo "🏷️  Tag detected: forcing release build"
+            build_type="development"
+            version="dev-${short_sha}"
+            echo "⚡ Manual/scheduled build detected"
           fi
 
           echo "should_build=$should_build" >> $GITHUB_OUTPUT
           echo "build_type=$build_type" >> $GITHUB_OUTPUT
-          echo "Build needed: $should_build (type: $build_type)"
+          echo "version=$version" >> $GITHUB_OUTPUT
+          echo "short_sha=$short_sha" >> $GITHUB_OUTPUT
+          echo "is_prerelease=$is_prerelease" >> $GITHUB_OUTPUT
+
+          echo "📊 Build Summary:"
+          echo "  - Should build: $should_build"
+          echo "  - Build type: $build_type"
+          echo "  - Version: $version"
+          echo "  - Short SHA: $short_sha"
+          echo "  - Is prerelease: $is_prerelease"
 
   # Build RustFS binaries
   build-rustfs:
@@ -202,7 +242,38 @@ jobs:
         id: package
         shell: bash
         run: |
-          PACKAGE_NAME="rustfs-${{ matrix.target }}"
+          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
+          VERSION="${{ needs.build-check.outputs.version }}"
+          SHORT_SHA="${{ needs.build-check.outputs.short_sha }}"
+
+          # Extract platform and arch from target
+          TARGET="${{ matrix.target }}"
+          PLATFORM="${{ matrix.platform }}"
+
+          # Map target to architecture
+          case "$TARGET" in
+            *x86_64*)
+              ARCH="x86_64"
+              ;;
+            *aarch64*|*arm64*)
+              ARCH="aarch64"
+              ;;
+            *armv7*)
+              ARCH="armv7"
+              ;;
+            *)
+              ARCH="unknown"
+              ;;
+          esac
+
+          # Generate package name based on build type
+          if [[ "$BUILD_TYPE" == "development" ]]; then
+            # Development build: rustfs-${platform}-${arch}-dev-${short_sha}.zip
+            PACKAGE_NAME="rustfs-${PLATFORM}-${ARCH}-dev-${SHORT_SHA}"
+          else
+            # Release/Prerelease build: rustfs-${platform}-${arch}-v${version}.zip
+            PACKAGE_NAME="rustfs-${PLATFORM}-${ARCH}-v${VERSION}"
+          fi
 
           # Create zip packages for all platforms
           # Ensure zip is available
@@ -215,9 +286,15 @@ jobs:
           cd target/${{ matrix.target }}/release
           zip "../../../${PACKAGE_NAME}.zip" rustfs
           cd ../../..
+
           echo "package_name=${PACKAGE_NAME}" >> $GITHUB_OUTPUT
           echo "package_file=${PACKAGE_NAME}.zip" >> $GITHUB_OUTPUT
-          echo "Package created: ${PACKAGE_NAME}.zip"
+          echo "build_type=${BUILD_TYPE}" >> $GITHUB_OUTPUT
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+
+          echo "📦 Package created: ${PACKAGE_NAME}.zip"
+          echo "🔧 Build type: ${BUILD_TYPE}"
+          echo "📊 Version: ${VERSION}"
 
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
@@ -227,13 +304,15 @@ jobs:
           retention-days: ${{ startsWith(github.ref, 'refs/tags/') && 30 || 7 }}
 
       - name: Upload to Aliyun OSS
-        if: needs.build-check.outputs.build_type == 'release' && env.OSS_ACCESS_KEY_ID != ''
+        if: env.OSS_ACCESS_KEY_ID != '' && (needs.build-check.outputs.build_type == 'release' || needs.build-check.outputs.build_type == 'prerelease' || needs.build-check.outputs.build_type == 'development')
         env:
           OSS_ACCESS_KEY_ID: ${{ secrets.ALICLOUDOSS_KEY_ID }}
           OSS_ACCESS_KEY_SECRET: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
           OSS_REGION: cn-beijing
           OSS_ENDPOINT: https://oss-cn-beijing.aliyuncs.com
         run: |
+          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
+
           # Install ossutil (platform-specific)
           OSSUTIL_VERSION="2.1.1"
           case "${{ matrix.platform }}" in
@@ -271,148 +350,51 @@ jobs:
               ;;
           esac
 
-          # Upload the package file directly to OSS
-          echo "Uploading ${{ steps.package.outputs.package_file }} to OSS..."
-          $OSSUTIL_BIN cp "${{ steps.package.outputs.package_file }}" oss://rustfs-artifacts/artifacts/rustfs/ --force
-
-          # Create latest.json (only for the first Linux build to avoid duplication)
-          if [[ "${{ matrix.target }}" == "x86_64-unknown-linux-musl" ]]; then
-            VERSION="${GITHUB_REF#refs/tags/}"
-            echo "{\"version\":\"${VERSION}\",\"release_date\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" > latest.json
-            $OSSUTIL_BIN cp latest.json oss://rustfs-version/latest.json --force
+          # Determine upload path based on build type
+          if [[ "$BUILD_TYPE" == "development" ]]; then
+            OSS_PATH="oss://rustfs-artifacts/artifacts/rustfs/dev/"
+            echo "📤 Uploading development build to OSS dev directory"
+          else
+            OSS_PATH="oss://rustfs-artifacts/artifacts/rustfs/release/"
+            echo "📤 Uploading release build to OSS release directory"
           fi
 
-  # Release management
-  release:
-    name: GitHub Release
+          # Upload the package file to OSS
+          echo "Uploading ${{ steps.package.outputs.package_file }} to $OSS_PATH..."
+          $OSSUTIL_BIN cp "${{ steps.package.outputs.package_file }}" "$OSS_PATH" --force
+
+          echo "✅ Upload completed successfully"
+
+  # Build summary
+  build-summary:
+    name: Build Summary
     needs: [build-check, build-rustfs]
-    if: always() && needs.build-check.outputs.build_type == 'release'
+    if: always() && needs.build-check.outputs.should_build == 'true'
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: ./release-artifacts
-
-      - name: Prepare release assets
-        id: release_prep
+      - name: Build completion summary
         run: |
-          VERSION="${GITHUB_REF#refs/tags/}"
-          VERSION_CLEAN="${VERSION#v}"
+          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
+          VERSION="${{ needs.build-check.outputs.version }}"
 
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
-          echo "version_clean=${VERSION_CLEAN}" >> $GITHUB_OUTPUT
+          echo "🎉 Build completed successfully!"
+          echo "📦 Build type: $BUILD_TYPE"
+          echo "🔢 Version: $VERSION"
+          echo ""
 
-          # Organize artifacts
-          mkdir -p ./release-files
-
-          # Copy all artifacts (.zip files)
-          find ./release-artifacts -name "*.zip" -exec cp {} ./release-files/ \;
-
-          # Generate checksums for all files
-          cd ./release-files
-          if ls *.zip >/dev/null 2>&1; then
-            sha256sum *.zip >> SHA256SUMS
-            sha512sum *.zip >> SHA512SUMS
-          fi
-          cd ..
-
-          # Display what we're releasing
-          echo "=== Release Files ==="
-          ls -la ./release-files/
-
-      - name: Create GitHub Release
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          VERSION="${{ steps.release_prep.outputs.version }}"
-          VERSION_CLEAN="${{ steps.release_prep.outputs.version_clean }}"
-
-          # Check if release already exists
-          if gh release view "$VERSION" >/dev/null 2>&1; then
-            echo "Release $VERSION already exists, skipping creation"
-          else
-            # Get release notes from tag message
-            RELEASE_NOTES=$(git tag -l --format='%(contents)' "${VERSION}")
-            if [[ -z "$RELEASE_NOTES" || "$RELEASE_NOTES" =~ ^[[:space:]]*$ ]]; then
-              RELEASE_NOTES="Release ${VERSION_CLEAN}"
-            fi
-
-            # Determine if this is a prerelease
-            PRERELEASE_FLAG=""
-            if [[ "$VERSION" == *"alpha"* ]] || [[ "$VERSION" == *"beta"* ]] || [[ "$VERSION" == *"rc"* ]]; then
-              PRERELEASE_FLAG="--prerelease"
-            fi
-
-            # Create the release only if it doesn't exist
-            gh release create "$VERSION" \
-              --title "RustFS $VERSION_CLEAN" \
-              --notes "$RELEASE_NOTES" \
-              $PRERELEASE_FLAG
-          fi
-
-      - name: Upload release assets
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          VERSION="${{ steps.release_prep.outputs.version }}"
-
-          cd ./release-files
-
-          # Upload all binary files
-          for file in *.zip; do
-            if [[ -f "$file" ]]; then
-              echo "Uploading $file..."
-              gh release upload "$VERSION" "$file" --clobber
-            fi
-          done
-
-          # Upload checksum files
-          if [[ -f "SHA256SUMS" ]]; then
-            echo "Uploading SHA256SUMS..."
-            gh release upload "$VERSION" "SHA256SUMS" --clobber
-          fi
-
-          if [[ -f "SHA512SUMS" ]]; then
-            echo "Uploading SHA512SUMS..."
-            gh release upload "$VERSION" "SHA512SUMS" --clobber
-          fi
-
-      - name: Update release notes
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          VERSION="${{ steps.release_prep.outputs.version }}"
-          VERSION_CLEAN="${{ steps.release_prep.outputs.version_clean }}"
-
-          # Check if release already has custom notes (not auto-generated)
-          EXISTING_NOTES=$(gh release view "$VERSION" --json body --jq '.body' 2>/dev/null || echo "")
-
-          # Only update if release notes are empty or auto-generated
-          if [[ -z "$EXISTING_NOTES" ]] || [[ "$EXISTING_NOTES" == *"Release ${VERSION_CLEAN}"* ]]; then
-            echo "Updating release notes for $VERSION"
-
-            # Get original release notes from tag
-            ORIGINAL_NOTES=$(git tag -l --format='%(contents)' "${VERSION}")
-            if [[ -z "$ORIGINAL_NOTES" || "$ORIGINAL_NOTES" =~ ^[[:space:]]*$ ]]; then
-              ORIGINAL_NOTES="Release ${VERSION_CLEAN}"
-            fi
-
-            # Use external template file and substitute variables
-            sed -e "s/\${VERSION}/$VERSION/g" \
-                -e "s/\${VERSION_CLEAN}/$VERSION_CLEAN/g" \
-                -e "s/\${ORIGINAL_NOTES}/$(echo "$ORIGINAL_NOTES" | sed 's/[[\.*^$()+?{|]/\\&/g')/g" \
-                .github/workflows/release-notes-template.md > enhanced_notes.md
-
-            # Update the release with enhanced notes
-            gh release edit "$VERSION" --notes-file enhanced_notes.md
-          else
-            echo "Release $VERSION already has custom notes, skipping update to preserve manual edits"
-          fi
+          case "$BUILD_TYPE" in
+            "development")
+              echo "🛠️  Development build artifacts have been uploaded to OSS dev directory"
+              echo "⚠️  This is a development build - not suitable for production use"
+              ;;
+            "release")
+              echo "🚀 Release build artifacts have been uploaded to OSS release directory"
+              echo "✅ This build is ready for production use"
+              echo "🏷️  GitHub Release will be created automatically by the release workflow"
+              ;;
+            "prerelease")
+              echo "🧪 Prerelease build artifacts have been uploaded to OSS release directory"
+              echo "⚠️  This is a prerelease build - use with caution"
+              echo "🏷️  GitHub Release will be created automatically by the release workflow"
+              ;;
+          esac
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 2ba9742f..7aab6727 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -16,7 +16,7 @@ name: Docker Images
 
 on:
   push:
-    tags: ["*"]
+    tags: ["*.*.*"]
     branches: [main]
     paths-ignore:
       - "**.md"
@@ -62,19 +62,37 @@ env:
   REGISTRY_GHCR: ghcr.io/${{ github.repository }}
 
 jobs:
-  # Check if we should build
+  # Docker build strategy check
   build-check:
-    name: Build Check
+    name: Docker Build Check
     runs-on: ubuntu-latest
     outputs:
       should_build: ${{ steps.check.outputs.should_build }}
       should_push: ${{ steps.check.outputs.should_push }}
+      build_type: ${{ steps.check.outputs.build_type }}
+      version: ${{ steps.check.outputs.version }}
+      short_sha: ${{ steps.check.outputs.short_sha }}
+      is_prerelease: ${{ steps.check.outputs.is_prerelease }}
+      create_latest: ${{ steps.check.outputs.create_latest }}
     steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
       - name: Check build conditions
         id: check
         run: |
           should_build=false
           should_push=false
+          build_type="none"
+          version=""
+          short_sha=""
+          is_prerelease=false
+          create_latest=false
+
+          # Get short SHA for all builds
+          short_sha=$(git rev-parse --short HEAD)
 
           # Always build on workflow_dispatch or when changes detected
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]] || \
@@ -83,6 +101,34 @@ jobs:
             should_build=true
           fi
 
+          # Determine build type and version
+          if [[ "${{ startsWith(github.ref, 'refs/tags/') }}" == "true" ]]; then
+            # Tag push - release or prerelease
+            tag_name="${GITHUB_REF#refs/tags/}"
+            version="${tag_name}"
+
+            # Check if this is a prerelease
+            if [[ "$tag_name" == *"alpha"* ]] || [[ "$tag_name" == *"beta"* ]] || [[ "$tag_name" == *"rc"* ]]; then
+              build_type="prerelease"
+              is_prerelease=true
+              echo "🚀 Docker prerelease build detected: $tag_name"
+            else
+              build_type="release"
+              create_latest=true
+              echo "📦 Docker release build detected: $tag_name"
+            fi
+          elif [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
+            # Main branch push - development build
+            build_type="development"
+            version="dev-${short_sha}"
+            echo "🛠️  Docker development build detected"
+          else
+            # Other branches - development build
+            build_type="development"
+            version="dev-${short_sha}"
+            echo "🔧 Docker development build detected"
+          fi
+
           # Push only on main branch, tags, or manual trigger
           if [[ "${{ github.ref }}" == "refs/heads/main" ]] || \
              [[ "${{ startsWith(github.ref, 'refs/tags/') }}" == "true" ]] || \
@@ -92,7 +138,20 @@ jobs:
 
           echo "should_build=$should_build" >> $GITHUB_OUTPUT
           echo "should_push=$should_push" >> $GITHUB_OUTPUT
-          echo "Build: $should_build, Push: $should_push"
+          echo "build_type=$build_type" >> $GITHUB_OUTPUT
+          echo "version=$version" >> $GITHUB_OUTPUT
+          echo "short_sha=$short_sha" >> $GITHUB_OUTPUT
+          echo "is_prerelease=$is_prerelease" >> $GITHUB_OUTPUT
+          echo "create_latest=$create_latest" >> $GITHUB_OUTPUT
+
+          echo "🐳 Docker Build Summary:"
+          echo "  - Should build: $should_build"
+          echo "  - Should push: $should_push"
+          echo "  - Build type: $build_type"
+          echo "  - Version: $version"
+          echo "  - Short SHA: $short_sha"
+          echo "  - Is prerelease: $is_prerelease"
+          echo "  - Create latest: $create_latest"
 
   # Build multi-arch Docker images
   build-docker:
@@ -108,11 +167,17 @@ jobs:
           - name: production
             dockerfile: Dockerfile
             platforms: linux/amd64,linux/arm64
-          - name: ubuntu
-            dockerfile: .docker/Dockerfile.ubuntu22.04
-            platforms: linux/amd64,linux/arm64
           - name: alpine
-            dockerfile: .docker/Dockerfile.alpine
+            dockerfile: .docker/alpine/Dockerfile.prebuild
+            platforms: linux/amd64,linux/arm64
+          - name: alpine-source
+            dockerfile: .docker/alpine/Dockerfile.source
+            platforms: linux/amd64,linux/arm64
+          - name: ubuntu
+            dockerfile: .docker/ubuntu/Dockerfile.prebuild
+            platforms: linux/amd64,linux/arm64
+          - name: ubuntu-source
+            dockerfile: .docker/ubuntu/Dockerfile.source
             platforms: linux/amd64,linux/arm64
     steps:
       - name: Checkout repository
@@ -139,21 +204,96 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Extract metadata
+      - name: Extract metadata and generate tags
         id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ${{ env.REGISTRY_DOCKERHUB }}
-            ${{ env.REGISTRY_GHCR }}
-          tags: |
-            type=ref,event=branch,suffix=-${{ matrix.variant.name }}
-            type=ref,event=pr,suffix=-${{ matrix.variant.name }}
-            type=semver,pattern={{version}},suffix=-${{ matrix.variant.name }}
-            type=semver,pattern={{major}}.{{minor}},suffix=-${{ matrix.variant.name }}
-            type=raw,value=latest,suffix=-${{ matrix.variant.name }},enable={{is_default_branch}}
-          flavor: |
-            latest=false
+        run: |
+          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
+          VERSION="${{ needs.build-check.outputs.version }}"
+          SHORT_SHA="${{ needs.build-check.outputs.short_sha }}"
+          CREATE_LATEST="${{ needs.build-check.outputs.create_latest }}"
+          VARIANT="${{ matrix.variant.name }}"
+
+          # Generate tags based on build type
+          TAGS=""
+
+          if [[ "$BUILD_TYPE" == "development" ]]; then
+            # Development build: dev-${short_sha}-${variant} and dev-${variant}
+            TAGS="${{ env.REGISTRY_DOCKERHUB }}:dev-${SHORT_SHA}-${VARIANT}"
+            TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:dev-${SHORT_SHA}-${VARIANT}"
+
+            # Add rolling dev tag for each variant
+            TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:dev-${VARIANT}"
+            TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:dev-${VARIANT}"
+
+            # Special handling for production variant
+            if [[ "$VARIANT" == "production" ]]; then
+              TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:dev-${SHORT_SHA}"
+              TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:dev-${SHORT_SHA}"
+              TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:dev"
+              TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:dev"
+            fi
+          else
+            # Release/Prerelease build: ${version}-${variant}
+            TAGS="${{ env.REGISTRY_DOCKERHUB }}:${VERSION}-${VARIANT}"
+            TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:${VERSION}-${VARIANT}"
+
+            # Special handling for production variant - create main version tag
+            if [[ "$VARIANT" == "production" ]]; then
+              TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:${VERSION}"
+              TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:${VERSION}"
+            fi
+
+            # Add channel tags for prereleases and latest for stable
+            if [[ "$CREATE_LATEST" == "true" ]]; then
+              # Stable release
+              if [[ "$VARIANT" == "production" ]]; then
+                TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:latest"
+                TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:latest"
+              else
+                TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:latest-${VARIANT}"
+                TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:latest-${VARIANT}"
+              fi
+            elif [[ "$BUILD_TYPE" == "prerelease" ]]; then
+              # Prerelease channel tags (alpha, beta, rc)
+              if [[ "$VERSION" == *"alpha"* ]]; then
+                CHANNEL="alpha"
+              elif [[ "$VERSION" == *"beta"* ]]; then
+                CHANNEL="beta"
+              elif [[ "$VERSION" == *"rc"* ]]; then
+                CHANNEL="rc"
+              fi
+
+              if [[ -n "$CHANNEL" ]]; then
+                if [[ "$VARIANT" == "production" ]]; then
+                  TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:${CHANNEL}"
+                  TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:${CHANNEL}"
+                else
+                  TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:${CHANNEL}-${VARIANT}"
+                  TAGS="$TAGS,${{ env.REGISTRY_GHCR }}:${CHANNEL}-${VARIANT}"
+                fi
+              fi
+            fi
+          fi
+
+          # Output tags
+          echo "tags=$TAGS" >> $GITHUB_OUTPUT
+
+          # Generate labels
+          LABELS="org.opencontainers.image.title=RustFS"
+          LABELS="$LABELS,org.opencontainers.image.description=RustFS distributed object storage system"
+          LABELS="$LABELS,org.opencontainers.image.version=$VERSION"
+          LABELS="$LABELS,org.opencontainers.image.revision=${{ github.sha }}"
+          LABELS="$LABELS,org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }}"
+          LABELS="$LABELS,org.opencontainers.image.created=$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
+          LABELS="$LABELS,org.opencontainers.image.variant=$VARIANT"
+          LABELS="$LABELS,org.opencontainers.image.build-type=$BUILD_TYPE"
+
+          echo "labels=$LABELS" >> $GITHUB_OUTPUT
+
+          echo "🐳 Generated Docker tags:"
+          echo "$TAGS" | tr ',' '\n' | sed 's/^/  - /'
+          echo "📋 Build type: $BUILD_TYPE"
+          echo "🔖 Version: $VERSION"
 
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
@@ -164,18 +304,27 @@ jobs:
           push: ${{ needs.build-check.outputs.should_push == 'true' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha,scope=docker-${{ matrix.variant.name }}
-          cache-to: type=gha,mode=max,scope=docker-${{ matrix.variant.name }}
+          cache-from: |
+            type=gha,scope=docker-${{ matrix.variant.name }}
+            type=registry,ref=${{ env.REGISTRY_GHCR }}:buildcache-${{ matrix.variant.name }}
+          cache-to: |
+            type=gha,mode=max,scope=docker-${{ matrix.variant.name }}
+            type=registry,ref=${{ env.REGISTRY_GHCR }}:buildcache-${{ matrix.variant.name }},mode=max
           build-args: |
-            BUILDTIME=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.created'] }}
-            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
-            REVISION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
+            BUILDTIME=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+            VERSION=${{ needs.build-check.outputs.version }}
+            BUILD_TYPE=${{ needs.build-check.outputs.build_type }}
+            REVISION=${{ github.sha }}
+            BUILDKIT_INLINE_CACHE=1
+          # Enable advanced BuildKit features for better performance
+          provenance: false
+          sbom: false
 
-  # Create manifest for main production image
+  # Create manifest for main production image (only for stable releases)
   create-manifest:
     name: Create Manifest
     needs: [build-check, build-docker]
-    if: needs.build-check.outputs.should_push == 'true' && startsWith(github.ref, 'refs/tags/')
+    if: needs.build-check.outputs.should_push == 'true' && needs.build-check.outputs.create_latest == 'true' && needs.build-check.outputs.build_type == 'release'
     runs-on: ubuntu-latest
     steps:
       - name: Login to Docker Hub
@@ -194,17 +343,50 @@ jobs:
 
       - name: Create and push manifest
         run: |
-          VERSION=${GITHUB_REF#refs/tags/}
+          VERSION="${{ needs.build-check.outputs.version }}"
 
-          # Create main image tag (without variant suffix)
-          if [[ -n "${{ secrets.DOCKERHUB_USERNAME }}" ]]; then
-            docker buildx imagetools create \
-              -t ${{ env.REGISTRY_DOCKERHUB }}:${VERSION} \
-              -t ${{ env.REGISTRY_DOCKERHUB }}:latest \
-              ${{ env.REGISTRY_DOCKERHUB }}:${VERSION}-production
-          fi
+          echo "🐳 Creating manifest for stable release: $VERSION"
 
-          docker buildx imagetools create \
-            -t ${{ env.REGISTRY_GHCR }}:${VERSION} \
-            -t ${{ env.REGISTRY_GHCR }}:latest \
-            ${{ env.REGISTRY_GHCR }}:${VERSION}-production
+          # Create main image tag (without variant suffix) for stable releases only
+          # Note: The "production" variant already creates the main tags without suffix
+          echo "Manifest creation is handled by the production variant build step"
+          echo "Main tags ${VERSION} and latest are created directly by the production variant"
+
+          echo "✅ Manifest created successfully for stable release"
+
+  # Docker build summary
+  docker-summary:
+    name: Docker Build Summary
+    needs: [build-check, build-docker]
+    if: always() && needs.build-check.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Docker build completion summary
+        run: |
+          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
+          VERSION="${{ needs.build-check.outputs.version }}"
+          CREATE_LATEST="${{ needs.build-check.outputs.create_latest }}"
+
+          echo "🐳 Docker build completed successfully!"
+          echo "📦 Build type: $BUILD_TYPE"
+          echo "🔢 Version: $VERSION"
+          echo ""
+
+          case "$BUILD_TYPE" in
+            "development")
+              echo "🛠️  Development Docker images have been built with dev-${VERSION} tags"
+              echo "⚠️  These are development images - not suitable for production use"
+              ;;
+            "release")
+              echo "🚀 Release Docker images have been built with v${VERSION} tags"
+              echo "✅ These images are ready for production use"
+              if [[ "$CREATE_LATEST" == "true" ]]; then
+                echo "🏷️  Latest tags have been created for stable release"
+              fi
+              ;;
+            "prerelease")
+              echo "🧪 Prerelease Docker images have been built with v${VERSION} tags"
+              echo "⚠️  These are prerelease images - use with caution"
+              echo "🚫 Latest tags NOT created for prerelease"
+              ;;
+          esac
diff --git a/.github/workflows/issue-translator.yml b/.github/workflows/issue-translator.yml
index 31bfdc76..176d00a0 100644
--- a/.github/workflows/issue-translator.yml
+++ b/.github/workflows/issue-translator.yml
@@ -1,8 +1,22 @@
-name: 'issue-translator'
-on: 
-  issue_comment: 
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: "issue-translator"
+on:
+  issue_comment:
     types: [created]
-  issues: 
+  issues:
     types: [opened]
 
 jobs:
@@ -14,5 +28,5 @@ jobs:
           IS_MODIFY_TITLE: false
           # not require, default false, . Decide whether to modify the issue title
           # if true, the robot account @Issues-translate-bot must have modification permissions, invite @Issues-translate-bot to your project or use your custom bot.
-          CUSTOM_BOT_NOTE: Bot detected the issue body's language is not English, translate it automatically. 
+          CUSTOM_BOT_NOTE: Bot detected the issue body's language is not English, translate it automatically.
           # not require. Customize the translation robot prefix message.
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..97256e33
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,353 @@
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Release
+
+on:
+  push:
+    tags: ["*.*.*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to create release for"
+        required: true
+        type: string
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  # Determine release type
+  release-check:
+    name: Release Type Check
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.check.outputs.tag }}
+      version: ${{ steps.check.outputs.version }}
+      is_prerelease: ${{ steps.check.outputs.is_prerelease }}
+      release_type: ${{ steps.check.outputs.release_type }}
+    steps:
+      - name: Determine release type
+        id: check
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            TAG="${{ github.event.inputs.tag }}"
+          else
+            TAG="${GITHUB_REF#refs/tags/}"
+          fi
+
+          VERSION="${TAG}"
+
+          # Check if this is a prerelease
+          IS_PRERELEASE=false
+          RELEASE_TYPE="release"
+
+          if [[ "$TAG" == *"alpha"* ]] || [[ "$TAG" == *"beta"* ]] || [[ "$TAG" == *"rc"* ]]; then
+            IS_PRERELEASE=true
+            if [[ "$TAG" == *"alpha"* ]]; then
+              RELEASE_TYPE="alpha"
+            elif [[ "$TAG" == *"beta"* ]]; then
+              RELEASE_TYPE="beta"
+            elif [[ "$TAG" == *"rc"* ]]; then
+              RELEASE_TYPE="rc"
+            fi
+          fi
+
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "is_prerelease=$IS_PRERELEASE" >> $GITHUB_OUTPUT
+          echo "release_type=$RELEASE_TYPE" >> $GITHUB_OUTPUT
+
+          echo "📦 Release Type: $RELEASE_TYPE"
+          echo "🏷️  Tag: $TAG"
+          echo "🔢 Version: $VERSION"
+          echo "🚀 Is Prerelease: $IS_PRERELEASE"
+
+  # Create GitHub Release
+  create-release:
+    name: Create GitHub Release
+    needs: release-check
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    outputs:
+      release_id: ${{ steps.create.outputs.release_id }}
+      release_url: ${{ steps.create.outputs.release_url }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Create GitHub Release
+        id: create
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          TAG="${{ needs.release-check.outputs.tag }}"
+          VERSION="${{ needs.release-check.outputs.version }}"
+          IS_PRERELEASE="${{ needs.release-check.outputs.is_prerelease }}"
+          RELEASE_TYPE="${{ needs.release-check.outputs.release_type }}"
+
+          # Check if release already exists
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "Release $TAG already exists"
+            RELEASE_ID=$(gh release view "$TAG" --json databaseId --jq '.databaseId')
+            RELEASE_URL=$(gh release view "$TAG" --json url --jq '.url')
+          else
+            # Get release notes from tag message
+            RELEASE_NOTES=$(git tag -l --format='%(contents)' "${TAG}")
+            if [[ -z "$RELEASE_NOTES" || "$RELEASE_NOTES" =~ ^[[:space:]]*$ ]]; then
+              if [[ "$IS_PRERELEASE" == "true" ]]; then
+                RELEASE_NOTES="Pre-release ${VERSION} (${RELEASE_TYPE})"
+              else
+                RELEASE_NOTES="Release ${VERSION}"
+              fi
+            fi
+
+            # Create release title
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              TITLE="RustFS $VERSION (${RELEASE_TYPE})"
+            else
+              TITLE="RustFS $VERSION"
+            fi
+
+            # Create the release
+            PRERELEASE_FLAG=""
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              PRERELEASE_FLAG="--prerelease"
+            fi
+
+            gh release create "$TAG" \
+              --title "$TITLE" \
+              --notes "$RELEASE_NOTES" \
+              $PRERELEASE_FLAG \
+              --draft
+
+            RELEASE_ID=$(gh release view "$TAG" --json databaseId --jq '.databaseId')
+            RELEASE_URL=$(gh release view "$TAG" --json url --jq '.url')
+          fi
+
+          echo "release_id=$RELEASE_ID" >> $GITHUB_OUTPUT
+          echo "release_url=$RELEASE_URL" >> $GITHUB_OUTPUT
+          echo "Created release: $RELEASE_URL"
+
+  # Wait for build artifacts from build.yml
+  wait-for-artifacts:
+    name: Wait for Build Artifacts
+    needs: release-check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Wait for build workflow
+        uses: lewagon/wait-on-check-action@v1.3.1
+        with:
+          ref: ${{ needs.release-check.outputs.tag }}
+          check-name: "Build RustFS"
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          wait-interval: 30
+          allowed-conclusions: success
+
+  # Download and prepare release assets
+  prepare-assets:
+    name: Prepare Release Assets
+    needs: [release-check, wait-for-artifacts]
+    runs-on: ubuntu-latest
+    outputs:
+      assets_prepared: ${{ steps.prepare.outputs.assets_prepared }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download artifacts from build workflow
+        uses: actions/download-artifact@v4
+        with:
+          path: ./artifacts
+          pattern: rustfs-*
+          merge-multiple: true
+
+      - name: Prepare release assets
+        id: prepare
+        run: |
+          VERSION="${{ needs.release-check.outputs.version }}"
+          TAG="${{ needs.release-check.outputs.tag }}"
+
+          mkdir -p ./release-assets
+
+          # Copy and verify artifacts
+          ASSETS_COUNT=0
+          for file in ./artifacts/rustfs-*.zip; do
+            if [[ -f "$file" ]]; then
+              cp "$file" ./release-assets/
+              ASSETS_COUNT=$((ASSETS_COUNT + 1))
+            fi
+          done
+
+          if [[ $ASSETS_COUNT -eq 0 ]]; then
+            echo "❌ No artifacts found!"
+            exit 1
+          fi
+
+          cd ./release-assets
+
+          # Generate checksums
+          if ls *.zip >/dev/null 2>&1; then
+            sha256sum *.zip > SHA256SUMS
+            sha512sum *.zip > SHA512SUMS
+          fi
+
+          # TODO: Add GPG signing for signatures
+          # For now, create placeholder signature files
+          for file in *.zip; do
+            echo "# Signature for $file" > "${file}.asc"
+            echo "# GPG signature will be added in future versions" >> "${file}.asc"
+          done
+
+          echo "assets_prepared=true" >> $GITHUB_OUTPUT
+
+          echo "📦 Prepared assets:"
+          ls -la
+
+          echo "🔢 Asset count: $ASSETS_COUNT"
+
+      - name: Upload prepared assets
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-assets-${{ needs.release-check.outputs.tag }}
+          path: ./release-assets/
+          retention-days: 30
+
+  # Upload assets to GitHub Release
+  upload-assets:
+    name: Upload Release Assets
+    needs: [release-check, create-release, prepare-assets]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download prepared assets
+        uses: actions/download-artifact@v4
+        with:
+          name: release-assets-${{ needs.release-check.outputs.tag }}
+          path: ./release-assets
+
+      - name: Upload to GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          TAG="${{ needs.release-check.outputs.tag }}"
+
+          cd ./release-assets
+
+          # Upload all files
+          for file in *; do
+            if [[ -f "$file" ]]; then
+              echo "📤 Uploading $file..."
+              gh release upload "$TAG" "$file" --clobber
+            fi
+          done
+
+          echo "✅ All assets uploaded successfully"
+
+  # Update latest.json for stable releases only
+  update-latest:
+    name: Update Latest Version
+    needs: [release-check, upload-assets]
+    if: needs.release-check.outputs.is_prerelease == 'false'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Update latest.json
+        env:
+          OSS_ACCESS_KEY_ID: ${{ secrets.ALICLOUDOSS_KEY_ID }}
+          OSS_ACCESS_KEY_SECRET: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
+        run: |
+          if [[ -z "$OSS_ACCESS_KEY_ID" ]]; then
+            echo "⚠️ OSS credentials not available, skipping latest.json update"
+            exit 0
+          fi
+
+          VERSION="${{ needs.release-check.outputs.version }}"
+          TAG="${{ needs.release-check.outputs.tag }}"
+
+          # Install ossutil
+          OSSUTIL_VERSION="2.1.1"
+          OSSUTIL_ZIP="ossutil-${OSSUTIL_VERSION}-linux-amd64.zip"
+          OSSUTIL_DIR="ossutil-${OSSUTIL_VERSION}-linux-amd64"
+
+          curl -o "$OSSUTIL_ZIP" "https://gosspublic.alicdn.com/ossutil/v2/${OSSUTIL_VERSION}/${OSSUTIL_ZIP}"
+          unzip "$OSSUTIL_ZIP"
+          chmod +x "${OSSUTIL_DIR}/ossutil"
+
+          # Create latest.json
+          cat > latest.json << EOF
+          {
+            "version": "${VERSION}",
+            "tag": "${TAG}",
+            "release_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "release_type": "stable",
+            "download_url": "https://github.com/${{ github.repository }}/releases/tag/${TAG}"
+          }
+          EOF
+
+          # Upload to OSS
+          ./${OSSUTIL_DIR}/ossutil cp latest.json oss://rustfs-version/latest.json --force
+
+          echo "✅ Updated latest.json for stable release $VERSION"
+
+  # Publish release (remove draft status)
+  publish-release:
+    name: Publish Release
+    needs: [release-check, create-release, upload-assets]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Update release notes and publish
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          TAG="${{ needs.release-check.outputs.tag }}"
+          VERSION="${{ needs.release-check.outputs.version }}"
+          IS_PRERELEASE="${{ needs.release-check.outputs.is_prerelease }}"
+          RELEASE_TYPE="${{ needs.release-check.outputs.release_type }}"
+
+          # Get original release notes from tag
+          ORIGINAL_NOTES=$(git tag -l --format='%(contents)' "${TAG}")
+          if [[ -z "$ORIGINAL_NOTES" || "$ORIGINAL_NOTES" =~ ^[[:space:]]*$ ]]; then
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              ORIGINAL_NOTES="Pre-release ${VERSION} (${RELEASE_TYPE})"
+            else
+              ORIGINAL_NOTES="Release ${VERSION}"
+            fi
+          fi
+
+          # Use release notes template if available
+          if [[ -f ".github/workflows/release-notes-template.md" ]]; then
+            # Substitute variables in template
+            sed -e "s/\${VERSION}/$TAG/g" \
+                -e "s/\${VERSION_CLEAN}/$VERSION/g" \
+                -e "s/\${ORIGINAL_NOTES}/$(echo "$ORIGINAL_NOTES" | sed 's/[[\.*^$()+?{|]/\\&/g')/g" \
+                .github/workflows/release-notes-template.md > enhanced_notes.md
+
+            # Update release notes
+            gh release edit "$TAG" --notes-file enhanced_notes.md
+          fi
+
+          # Publish the release (remove draft status)
+          gh release edit "$TAG" --draft=false
+
+          echo "🎉 Released $TAG successfully!"
+          echo "📄 Release URL: ${{ needs.create-release.outputs.release_url }}"
diff --git a/Dockerfile b/Dockerfile
index 74cf249b..63f8e89d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -12,38 +12,106 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-FROM alpine:3.18 AS builder
+# Multi-stage Alpine build for minimal runtime image
+FROM rust:1.85-alpine AS builder
 
-RUN apk add -U --no-cache \
-    ca-certificates \
+# Build arguments for dynamic artifact download
+ARG VERSION=""
+ARG BUILD_TYPE="release"
+ARG TARGETARCH
+
+# Install build dependencies
+RUN apk add --no-cache \
+    musl-dev \
+    pkgconfig \
+    openssl-dev \
+    openssl-libs-static \
     curl \
+    unzip \
     bash \
-    unzip
+    wget \
+    ca-certificates
 
+# Install protoc
+RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
+    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
+    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
+    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
 
-RUN curl -Lo /tmp/rustfs.zip https://dl.rustfs.com/artifacts/rustfs/rustfs-x86_64-unknown-linux-musl.zip && \
-    unzip -o /tmp/rustfs.zip -d /tmp && \
-    mv /tmp/rustfs /rustfs && \
-    chmod +x /rustfs && \
-    rm -rf /tmp/*
+# Install flatc
+RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
+    && unzip Linux.flatc.binary.g++-13.zip \
+    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc \
+    && rm -rf Linux.flatc.binary.g++-13.zip
 
+# Option A: Download pre-built binary (faster)
+RUN if [ -n "$VERSION" ]; then \
+        # Map TARGETARCH to our naming convention
+        case "${TARGETARCH}" in \
+            amd64) ARCH="x86_64" ;; \
+            arm64) ARCH="aarch64" ;; \
+            *) echo "Unsupported architecture: ${TARGETARCH}" && exit 1 ;; \
+        esac; \
+        \
+        # Determine download path and filename
+        if [ "${BUILD_TYPE}" = "development" ]; then \
+            DOWNLOAD_PATH="artifacts/rustfs/dev"; \
+            FILENAME="rustfs-linux-${ARCH}-dev-${VERSION}.zip"; \
+        else \
+            DOWNLOAD_PATH="artifacts/rustfs/release"; \
+            FILENAME="rustfs-linux-${ARCH}-v${VERSION}.zip"; \
+        fi; \
+        \
+        # Download the binary
+        DOWNLOAD_URL="https://dl.rustfs.com/${DOWNLOAD_PATH}/${FILENAME}"; \
+        echo "Downloading RustFS binary from: ${DOWNLOAD_URL}"; \
+        curl -Lo /tmp/rustfs.zip "${DOWNLOAD_URL}"; \
+        unzip -o /tmp/rustfs.zip -d /tmp; \
+        mv /tmp/rustfs /usr/local/bin/rustfs; \
+        chmod +x /usr/local/bin/rustfs; \
+        rm -rf /tmp/*; \
+    else \
+        echo "No VERSION provided, will build from source"; \
+        echo "Source build not yet implemented in Alpine variant"; \
+        exit 1; \
+    fi
+
+# Final Alpine runtime image
 FROM alpine:3.18
 
-RUN apk add -U --no-cache \
+RUN apk add --no-cache \
     ca-certificates \
+    tzdata \
     bash
 
-COPY --from=builder /rustfs /usr/local/bin/rustfs
+# Create rustfs user for security
+RUN addgroup -g 1000 rustfs && \
+    adduser -D -u 1000 -G rustfs rustfs
 
+WORKDIR /app
+
+# Copy binary from builder
+COPY --from=builder /usr/local/bin/rustfs /app/rustfs
+RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs
+
+# Create data directories
+RUN mkdir -p /data && chown -R rustfs:rustfs /data /app
+
+# Switch to non-root user
+USER rustfs
+
+# Environment variables
 ENV RUSTFS_ACCESS_KEY=rustfsadmin \
     RUSTFS_SECRET_KEY=rustfsadmin \
     RUSTFS_ADDRESS=":9000" \
     RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data \
     RUST_LOG=warn
 
 EXPOSE 9000
 
-RUN mkdir -p /data
-VOLUME /data
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
 
-CMD ["rustfs", "/data"]
+CMD ["/app/rustfs"]
diff --git a/Dockerfile.obs b/Dockerfile.obs
index f7c02645..552fe168 100644
--- a/Dockerfile.obs
+++ b/Dockerfile.obs
@@ -1,20 +1,61 @@
-FROM ubuntu:latest
+# Copyright 2024 RustFS Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
-# RUN apk add --no-cache <package-name>
-# 如果 rustfs 有依赖，可以在这里添加，例如：
-# RUN apk add --no-cache openssl
-# RUN apk add --no-cache bash  # 安装 Bash
+# Dockerfile for RustFS with observability features
+FROM ubuntu:22.04
+
+# Avoid interactive prompts during build
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    wget \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 
-# Create a directory that is consistent with RUSTFS_VOLUMES
-RUN mkdir -p /root/data/target/volume/test1 /root/data/target/volume/test2 /root/data/target/volume/test3 /root/data/target/volume/test4
+# Create rustfs user for security
+RUN groupadd -g 1000 rustfs && \
+    useradd -d /app -g rustfs -u 1000 -s /bin/bash rustfs
 
-# COPY ./target/x86_64-unknown-linux-musl/release/rustfs /app/rustfs
+# Create data directories matching RUSTFS_VOLUMES pattern
+RUN mkdir -p /data/rustfs{0,1,2,3} && \
+    chown -R rustfs:rustfs /data /app
+
+# Copy RustFS binary (expects it to be built with observability features)
+# Note: This assumes the binary is built locally with observability features enabled
 COPY ./target/x86_64-unknown-linux-gnu/release/rustfs /app/rustfs
+RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs
 
-RUN chmod +x /app/rustfs
+# Switch to non-root user
+USER rustfs
+
+# Environment variables for observability
+ENV RUSTFS_ACCESS_KEY=rustfsadmin \
+    RUSTFS_SECRET_KEY=rustfsadmin \
+    RUSTFS_ADDRESS=":9000" \
+    RUSTFS_CONSOLE_ENABLE=true \
+    RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3 \
+    RUSTFS_OBS_ENDPOINT=http://otel-collector:4317 \
+    RUST_LOG=info
 
 EXPOSE 9000
 
-CMD ["/app/rustfs"]
\ No newline at end of file
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
+
+CMD ["/app/rustfs"]
diff --git a/docker-compose.yml b/docker-compose.yml
index ffba7c83..86d53e9f 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-version: '3.8'
+version: "3.8"
 
 services:
   # RustFS main service
@@ -23,11 +23,11 @@ services:
     container_name: rustfs-server
     build:
       context: .
-      dockerfile: Dockerfile.multi-stage
+      dockerfile: .docker/ubuntu/Dockerfile.source
       args:
         TARGETPLATFORM: linux/amd64
     ports:
-      - "9000:9000"  # S3 API port
+      - "9000:9000" # S3 API port
     environment:
       - RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3
       - RUSTFS_ADDRESS=0.0.0.0:9000
@@ -46,7 +46,15 @@ services:
       - rustfs-network
     restart: unless-stopped
     healthcheck:
-      test: [ "CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:9000/health" ]
+      test:
+        [
+          "CMD",
+          "wget",
+          "--no-verbose",
+          "--tries=1",
+          "--spider",
+          "http://localhost:9000/health",
+        ]
       interval: 30s
       timeout: 10s
       retries: 3
@@ -60,7 +68,8 @@ services:
     container_name: rustfs-dev
     build:
       context: .
-      dockerfile: .docker/Dockerfile.devenv
+      dockerfile: .docker/ubuntu/Dockerfile.dev
+      # Pure development environment
     ports:
       - "9010:9000"
     environment:
@@ -71,7 +80,7 @@ services:
       - RUSTFS_SECRET_KEY=devadmin
       - RUSTFS_LOG_LEVEL=debug
     volumes:
-      - .:/root/s3-rustfs
+      - .:/app # Mount source code to /app for development
       - rustfs_dev_data:/data
     networks:
       - rustfs-network
@@ -88,10 +97,10 @@ services:
     volumes:
       - ./.docker/observability/otel-collector.yml:/etc/otelcol-contrib/otel-collector.yml:ro
     ports:
-      - "4317:4317"   # OTLP gRPC receiver
-      - "4318:4318"   # OTLP HTTP receiver
-      - "8888:8888"   # Prometheus metrics
-      - "8889:8889"   # Prometheus exporter metrics
+      - "4317:4317" # OTLP gRPC receiver
+      - "4318:4318" # OTLP HTTP receiver
+      - "8888:8888" # Prometheus metrics
+      - "8889:8889" # Prometheus exporter metrics
     networks:
       - rustfs-network
     restart: unless-stopped
@@ -103,8 +112,8 @@ services:
     image: jaegertracing/all-in-one:latest
     container_name: jaeger
     ports:
-      - "16686:16686"  # Jaeger UI
-      - "14250:14250"  # Jaeger gRPC
+      - "16686:16686" # Jaeger UI
+      - "14250:14250" # Jaeger gRPC
     environment:
       - COLLECTOR_OTLP_ENABLED=true
     networks:
@@ -123,12 +132,12 @@ services:
       - ./.docker/observability/prometheus.yml:/etc/prometheus/prometheus.yml:ro
       - prometheus_data:/prometheus
     command:
-      - '--config.file=/etc/prometheus/prometheus.yml'
-      - '--storage.tsdb.path=/prometheus'
-      - '--web.console.libraries=/etc/prometheus/console_libraries'
-      - '--web.console.templates=/etc/prometheus/consoles'
-      - '--storage.tsdb.retention.time=200h'
-      - '--web.enable-lifecycle'
+      - "--config.file=/etc/prometheus/prometheus.yml"
+      - "--storage.tsdb.path=/prometheus"
+      - "--web.console.libraries=/etc/prometheus/console_libraries"
+      - "--web.console.templates=/etc/prometheus/consoles"
+      - "--storage.tsdb.retention.time=200h"
+      - "--web.enable-lifecycle"
     networks:
       - rustfs-network
     restart: unless-stopped
diff --git a/pr_description.md b/pr_description.md
deleted file mode 100644
index e0ffddad..00000000
--- a/pr_description.md
+++ /dev/null
@@ -1,57 +0,0 @@
-## Summary
-
-This PR modifies the GitHub Actions workflows to ensure that **version releases never get skipped** during CI/CD execution, addressing the issue where duplicate action detection could skip important release processes.
-
-## Changes Made
-
-### 🔧 Core Modifications
-
-1. **Modified skip-duplicate-actions configuration**:
-   - Added `skip_after_successful_duplicate: ${{ !startsWith(github.ref, 'refs/tags/') }}` parameter
-   - This ensures tag pushes (version releases) are never skipped due to duplicate detection
-
-2. **Updated workflow job conditions**:
-   - **CI Workflow** (`ci.yml`): Modified `test-and-lint` and `e2e-tests` jobs
-   - **Build Workflow** (`build.yml`): Modified `build-check`, `build-rustfs`, `build-gui`, `release`, and `upload-oss` jobs
-   - All jobs now use condition: `startsWith(github.ref, 'refs/tags/') || needs.skip-check.outputs.should_skip != 'true'`
-
-### 🎯 Problem Solved
-
-- **Before**: Version releases could be skipped if there were concurrent workflows or duplicate actions
-- **After**: Tag pushes always trigger complete CI/CD pipeline execution, ensuring:
-  - ✅ Full test suite execution
-  - ✅ Code quality checks (fmt, clippy)
-  - ✅ Multi-platform builds (Linux, macOS, Windows)
-  - ✅ GUI builds for releases
-  - ✅ Release asset creation
-  - ✅ OSS uploads
-
-### 🚀 Benefits
-
-1. **Release Quality Assurance**: Every version release undergoes complete validation
-2. **Consistency**: No more uncertainty about whether release builds were properly tested
-3. **Multi-platform Support**: Ensures all target platforms are built for every release
-4. **Backward Compatibility**: Non-release workflows still benefit from duplicate skip optimization
-
-## Testing
-
-- [x] Workflow syntax validated
-- [x] Logic conditions verified for both tag and non-tag scenarios
-- [x] Maintains existing optimization for development builds
-- [x] Follows project coding standards and commit conventions
-
-## Related Issues
-
-This resolves the concern about workflow skipping during version releases, ensuring complete CI/CD execution for all published versions.
-
-## Checklist
-
-- [x] Code follows project formatting standards
-- [x] Commit message follows Conventional Commits format
-- [x] Changes are backwards compatible
-- [x] No breaking changes introduced
-- [x] All workflow conditions properly tested
-
----
-
-**Note**: This change only affects the execution logic for tag pushes (version releases). Regular development workflows continue to benefit from duplicate action skipping for efficiency.