rustfs/Dockerfile.source

# Multi-stage Dockerfile for RustFS - LOCAL DEVELOPMENT ONLY
#
# ⚠️  IMPORTANT: This Dockerfile is for local development and testing only.
# ⚠️  It builds RustFS from source code and is NOT used in CI/CD pipelines.
# ⚠️  CI/CD pipeline uses pre-built binaries from Dockerfile instead.
#
# Usage for local development:
#   docker build -f Dockerfile.source -t rustfs:dev-local .
#   docker run --rm -p 9000:9000 rustfs:dev-local
#
# Supports cross-compilation for amd64 and arm64 architectures
ARG TARGETPLATFORM
ARG BUILDPLATFORM

# Build stage
FROM --platform=$BUILDPLATFORM rust:1.88-bookworm AS builder

# Re-declare build arguments after FROM (required for multi-stage builds)
ARG TARGETPLATFORM
ARG BUILDPLATFORM

# Debug: Print platform information
RUN echo "🐳 Build Info: BUILDPLATFORM=$BUILDPLATFORM, TARGETPLATFORM=$TARGETPLATFORM"

# Install required build dependencies
RUN apt-get update && apt-get install -y \
    wget \
    git \
    curl \
    unzip \
    gcc \
    pkg-config \
    libssl-dev \
    lld \
    && rm -rf /var/lib/apt/lists/*

# Note: sccache removed for simpler builds

# Install cross-compilation tools for ARM64
RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
        apt-get update && \
        apt-get install -y gcc-aarch64-linux-gnu && \
        rm -rf /var/lib/apt/lists/*; \
    fi

# 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

# Set up Rust targets based on platform
RUN set -e && \
    PLATFORM="${TARGETPLATFORM:-linux/amd64}" && \
    echo "🎯 Setting up Rust target for platform: $PLATFORM" && \
    case "$PLATFORM" in \
        "linux/amd64") rustup target add x86_64-unknown-linux-gnu ;; \
        "linux/arm64") rustup target add aarch64-unknown-linux-gnu ;; \
        *) echo "❌ Unsupported platform: $PLATFORM" && exit 1 ;; \
    esac

# Set up environment for cross-compilation
ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
ENV CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
ENV CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++

WORKDIR /usr/src/rustfs

# Copy all source code
COPY . .

# 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

# Generate protobuf code
RUN cargo run --bin gproto

# Build the actual application with optimizations
RUN case "$TARGETPLATFORM" in \
        "linux/amd64") \
            echo "🔨 Building for amd64..." && \
            rustup target add x86_64-unknown-linux-gnu && \
            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") \
            echo "🔨 Building for arm64..." && \
            rustup target add aarch64-unknown-linux-gnu && \
            cargo build --release --target aarch64-unknown-linux-gnu --bin rustfs -j $(nproc) && \
            cp target/aarch64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
            ;; \
        *) \
            echo "❌ Unsupported platform: $TARGETPLATFORM" && exit 1 \
            ;; \
    esac

# Runtime stage - Ubuntu minimal for better compatibility
FROM ubuntu:22.04

# Install runtime dependencies
RUN apt-get update && apt-get install -y \
    ca-certificates \
    tzdata \
    wget \
    coreutils \
    passwd \
    && rm -rf /var/lib/apt/lists/*

# Create rustfs user and group
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/rustfs{0,1,2,3} && \
    chown -R rustfs:rustfs /data /app

# Copy binary from builder stage
COPY --from=builder /usr/local/bin/rustfs /app/rustfs
RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs

# Copy entrypoint script
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

# Switch to non-root user
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

# Volume for data
VOLUME ["/data"]

# Set entrypoint and default command
ENTRYPOINT ["/entrypoint.sh"]
CMD ["/app/rustfs"]