RustFS 面试题

单线程 4K 随机读：
  RustFS: ~800,000 IOPS
  C-FUSE: ~500,000 IOPS
  Go-FUSE: ~300,000 IOPS

原因：Rust 编译优化 + 无 GC + 零拷贝数据路径

Meta Server 集群（3 或 5 节点）：
  - Leader：处理所有元数据写入（mkdir、rename、setattr）
  - Follower：复制日志，提供只读查询（lookup、getattr）
  - 客户端 FUSE/CSI 通过 Leader 进行写操作，可读 Follower

**高可用切换：**

**元数据存储后端：**
- 嵌入式 RocksDB（默认）：高性能键值存储
- 支持外部 etcd 或 TiKV：大规模集群

文件 1GB 被切分为 16 个 64MB Chunk：
  Chunk-1 → DataServer-1（副本：DS-2, DS-3）
  Chunk-2 → DataServer-2（副本：DS-3, DS-4）
  ...

每个 Chunk 的元数据：
  - Chunk ID（全局唯一）
  - 数据节点列表（主副本 + 各用副本）
  - 文件偏移起始位置
  - CRC32C 校验和

replica_policy:
  type: "multi_replica"  # 或 erasure_coding
  replica_count: 3
  placement: "rack_aware"  # 机架感知
  # rack_aware: 同一 Chunk 副本分布在不同的机架

读文件：
  Client → 查询 Meta Server 获取 Chunk 位置
  → 直接连接 DataServer 读取 Chunk
  → 合并 Chunk 返回完整文件

写文件：
  Client → Meta Server 分配 Chunk ID 和 DataServer
  → 数据流式写入主 DataServer
  → 主 DataServer 同步复制到副本
  → 确认回 Client

Kubernetes → PV/PVC/StorageClass
  → CSI Provisioner → RustFS CSI Controller
  → CSI Node → RustFS FUSE 客户端挂载
  → Pod 内可见 POSIX 文件系统

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: rustfs-storage
provisioner: rustfs.csi.io
parameters:
  # Meta Server 连接地址
  metaserver: meta-cluster.company.com:9500
  
  # 数据冗余
  replicaCount: "3"
  
  # 空间配额
  capacity: "100Gi"
  
  # 缓存配置
  cacheSize: "5Gi"
  cacheType: "writeback"
  
  # 挂载参数
  mountOptions: "noatime,noexec"
allowVolumeExpansion: true
reclaimPolicy: Delete
mountOptions:
- noatime
- sync

创建：PVC → CSI Provisioner → RustFS API → 创建 Volume → PV Ready
挂载：Pod 调度 → CSI Node → FUSE 挂载 → Pod 使用
扩容：修改 PVC size → CSI Resizer → RustFS API → 扩容 → Pod 感知
删除：删除 PVC → CSI Provisioner → RustFS API → 回收 → PV 删除

客户端与 DataServer 同节点时：
  → 使用 Unix Domain Socket 或共享内存通道
  → 绕过网络栈，延迟降低至 10μs
跨节点访问：
  → RDMA（如果可用）或 TCP
  → 默认 Maglev 一致性哈希选择最近节点

**4. 批量 I/O 聚合：**
- 小写请求（< 4KB）聚合为 64KB 写入
- 大幅降低 DataServer 的 I/O 操作次数
- 使用 tokio 异步运行时实现无阻塞聚合

**性能基线（64 节点集群）：**

DataServer 心跳超时（默认 5 秒）
  → Meta Server 标记为 suspected
  → 经过确认时间（10 秒）后标记为 down
  → 触发 Chunk 重建

**重建优先级：**

**恢复配置：**
```yaml
recovery:
  maxConcurrentChunks: 64     # 每 DataServer 最大并发重建 Chunk 数
  maxRecoveryBandwidth: 500MB/s  # 重建带宽限制
  minRecoveryNodeCount: 3     # 最低重建参与节点数
  nodeDownTimeout: 15s        # 确认节点离线超时

small_file:
  inline_threshold: 4096  # 内联文件大小上限
  merge_threshold: 65536  # 合并写入阈值
  slab_size: 4096         # Slab 分配粒度

**性能对比（大量小文件）：**

| 场景 | RustFS | 通用 NFS | CephFS |
|------|--------|---------|--------|
| 100 万文件 ls | 2 秒 | 30 秒+ | 8 秒 |
| 10K 文件并发创建 | 5 秒 | 45 秒 | 12 秒 |
| 小文件连续读写 IOPS | 150K | 10K | 80K |

security:
  tls:
    enabled: true
    certFile: /etc/rustfs/cert.pem
    keyFile: /etc/rustfs/key.pem
    caFile: /etc/rustfs/ca.pem
    minVersion: "1.2"

**访问控制：**
```yaml
acl:
  model: "posix"         # POSIX 模式
  root_squash: true      # root 降权
  trusted_auth: true     # 可信认证

# CLI 创建快照
rustfs snapshot create /data/project --name "pre-upgrade-snap"

# API 方式
curl -X POST https://meta-server:9500/v1/snapshot \
  -d '{"path":"/data/project","name":"pre-upgrade-snap"}'

快照创建时：
  1. 冻结该目录树的写入
  2. 记录当前 inode 版本号
  3. 解除冻结
  4. 后续写入产生新的 Chunk 版本（原 Chunk 被快照引用）
  5. 快照与活跃数据共享未修改的 Chunk

# 恢复到快照
rustfs snapshot restore /data/project --snapshot "pre-upgrade-snap"

# 创建可写克隆（独立卷）
rustfs snapshot clone "pre-upgrade-snap" \
  --target /data/project-v2

snapshot:
  maxSnapshotsPerVolume: 124
  retention:
    hourly: 24
    daily: 30
    weekly: 12
  autoCleanup: true

cache:
  type: "writeback"     # writeback（异步回写）/ writethrough（同步）
  maxSize: "10Gi"       # L2 缓存上限
  prefetch: "adaptive"  # 自适应预取
  eviction: "lru"       # 淘汰策略
  # LRU / LFU / ARC / 2Q

**预取策略：**
- 检测顺序读模式时，提前预取 4-64MB
- 小文件场景自动预取整个目录的 inode
- 自适应预取根据 I/O 模式动态调整

Meta Server: 3 节点（Raft 集群）
DataServer: 3+ 节点（副本策略：3 副本）
客户端：任意数量（FUSE / CSI）
网络：10GbE+ 冗余网络

# Meta Server 配置
cluster:
  mode: "raft"
  raftNodeCount: 3
  raftHeartbeatInterval: "500ms"
  raftElectionTimeout: "1.5s"

# 数据冗余
replication:
  type: "multi_replica"
  replicaCount: 3
  placementStrategy: "rack_aware"
  # rack_aware: 副本跨机架
  # host_aware: 副本跨主机
  # zone_aware: 跨可用区

network:
  ioThreads: 8              # IO 线程数（默认等于 CPU 核数）
  maxConnections: 10000     # 最大连接数
  tcpNoDelay: true          # 禁用 Nagle 算法
  sendBuffer: "2MiB"        # 发送缓冲区
  recvBuffer: "2MiB"        # 接收缓冲区

cache:
  L1Size: "512MiB"          # FUSE 内核缓存
  L2Size: "10GiB"           # 本地 SSD 缓存
  L3Size: "4GiB"            # DataServer 内存缓存
  prefetchBlocks: 8         # 预取的 Chunk 块数
  writeBufferSize: "64MiB"  # 写缓冲大小

concurrency:
  maxReadAhead: 64          # 最大预读并发数
  maxWritePending: 128      # 最大挂起写入数
  maxMetaRequests: 256      # 最大并发元数据请求
  ioDepth: 64               # 磁盘队列深度

disk:
  readAhead: "4MiB"         # 磁盘预读
  directIO: false           # 绕过页缓存
  ioEngine: "io_uring"      # 异步 I/O 引擎（io_uring / epoll / aio）

# 查看系统指标
rustfs stat --interval 5

# I/O 延迟分布
rustfs stat --latency

# Chunk 分布
rustfs stat --chunk-dist

apiVersion: storage.k8s.io/v1
kind: StorageClass
parameters:
  # 多租户配置
  tenant: "tenant-a"
  mountPermissions: "0700"

# 设置租户空间限制
rustfs quota set --tenant tenant-a --limit "1TiB" --fileLimit "10000000"
rustfs quota set --path /data/tenant-b --limit "500GiB"

# 查看配额使用
rustfs quota get --tenant tenant-a
# 输出: used: 600GiB, limit: 1TiB, fileCount: 4500000

# QoS 策略配置
qos:
  tenant-a:
    readIOPS: 100000
    writeIOPS: 50000
    readBandwidth: "500MB/s"
    writeBandwidth: "200MB/s"
  tenant-b:
    readIOPS: 50000
    writeIOPS: 25000
    readBandwidth: "200MB/s"
    writeBandwidth: "100MB/s"

# 容量配额
rustfs quota set /data/project --limit "1TiB"
# 文件数配额
rustfs quota set /data/project --fileLimit 1000000

# inode 配额
rustfs quota set /data/archive --inodeLimit 50000000

# 软限制：超过后告警，但仍可继续写入
quota:
  softLimit: "90%"
  gracePeriod: "7d"  # 软限制超限宽限期
  alertThreshold: "85%"

# 集群容量总览
rustfs quota cluster-status
# Total: 100TiB | Used: 65TiB | Avail: 35TiB | Usage: 65%

# 按租户
rustfs quota list --tenant
# tenant-a: 使用 12TiB / 限制 20TiB
# tenant-b: 使用 45TiB / 限制 60TiB

recycleBin:
  enabled: true
  path: "/.recycle"
  retentionDays: 30          # 保留 30 天
  maxSize: "100GiB"          # 回收站最大容量
  cleanInterval: "24h"       # 清理间隔

# 删除文件（进入回收站）
rm /data/project/config.yaml
# 实际移动到 /.recycle/2026-05-26/project/config.yaml

# 查看回收站内容
rustfs recycle list /data/project

# 恢复文件
rustfs recycle restore /.recycle/2026-05-26/project/config.yaml \
  --to /data/project/config.yaml

# 清空回收站
rustfs recycle clean

**数据同步机制：```
主集群写入 → 写入本地 Chunk
  → 异步复制引擎检测变更
  → 增量同步到灾备集群
  → 灾备集群延迟：秒级（同城）/ 分钟级（跨地域）

# 区域感知配置
region:
  name: "us-west-1"
  preferredReadNodes: ["ds-west-1*"]
  asyncReplication:
    enabled: true
    replicationTargets:
    - region: "us-east-1"
      priority: 1

audit:
  enabled: true
  format: "json"
  output: "/var/log/rustfs/audit.log"
  rotate:
    maxSize: "1GiB"
    maxFiles: 7
  events:
    - file_create     # 文件创建
    - file_delete     # 文件删除
    - file_write      # 文件写入
    - file_rename     # 文件重命名
    - permission_change  # 权限变更
    - quota_change    # 配额变更
    - snapshot_create # 快照创建
    - snapshot_delete # 快照删除

{
  "timestamp": "2026-05-26T10:30:00Z",
  "event": "file_delete",
  "user": "admin",
  "source": "10.0.1.100",
  "path": "/data/project/config.yaml",
  "inode": 123456,
  "size": 2048,
  "result": "success"
}

monitoring:
  prometheus:
    enabled: true
    port: 9580
    path: "/metrics"

apiVersion: v1
kind: ConfigMap
metadata:
  name: rustfs-grafana
  namespace: monitoring
data:
  rustfs-dashboard.json: |
    { "dashboard": { ... } }    

# 集群状态
rustfs status                # 整体集群健康
rustfs meta status          # 元数据集群状态（Raft）
rustfs data status          # 数据节点状态

# 元数据检查
rustfs fsck /data           # 文件系统一致性检查
rustfs fsck --repair        # 修复不一致问题
rustfs check-inode <id>     # 查看 inode 详细信息

# 数据检查
rustfs chunk list /data/file.txt   # 查看文件 Chunk 分布
rustfs chunk status <chunk-id>     # 查看 Chunk 副本状态

# 性能诊断
rustfs profile start        # 开始性能采样
rustfs profile stop         # 停止并输出报告
rustfs top                  # 实时 I/O Top

# 各组件日志
journalctl -u rustfs-meta    # 元数据服务日志
journalctl -u rustfs-data    # 数据服务日志
journalctl -u rustfs-fuse    # FUSE 客户端日志

# 日志级别调整
rustfs meta set-log-level debug
rustfs data set-log-level info

compression:
  algorithm: "zstd"      # 算法：lz4 / zstd / snappy
  level: 3               # 压缩等级（1-22，越高压缩率越好但越慢）
  minSize: "1MiB"        # 最小压缩文件大小
  chunkCompress: true    # Chunk 级别压缩
  online: true           # 在线压缩

disk:
  ssdOptimization:
    enabled: true
    # 日志结构合并（LSM Tree 风格）
    writePattern: "append"        # 追加写入，避免随机写
    trimInterval: "7d"            # TRIM/DISCARD 间隔
    overProvisioning: "10%"       # 预留空间
    wafTarget: "1.2"              # 目标写放大因子

无优化写放大：4x-10x（随机 4K 写入）
SSD 优化写放大：1.1x-1.5x（顺序追加写入）

# 卷管理
POST /v1/volume             # 创建卷
DELETE /v1/volume/{id}      # 删除卷
GET /v1/volume/{id}/stats   # 卷统计

# 快照管理
POST /v1/snapshot           # 创建快照
POST /v1/snapshot/restore   # 恢复快照
POST /v1/snapshot/clone     # 克隆快照

# 配额管理
PUT /v1/quota/{path}        # 设置配额
GET /v1/quota/{path}        # 查看配额

use rustfs::client::{RustFSClient, VolumeConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = RustFSClient::new("meta-cluster:9500").await?;
    
    // 创建卷
    let vol = client.create_volume(VolumeConfig {
        name: "k8s-vol-001",
        size: 100 * 1024 * 1024 * 1024, // 100GiB
        replica: 3,
    }).await?;
    
    println!("Volume created: {}", vol.id);
    Ok(())
}

大文件 50GB → 800 个 Chunk（每 64MB）
  → 客户端发起并行读取请求（默认 16 路并行）
  → 每个 Chunk 从不同的 DataServer 读取
  → 数据聚合后返回给应用

read:
  parallelChunks: 16     # 并行读取 Chunk 数
  minReadSize: "1MiB"    # 最小读取量（启动并行）
  prefetchWindow: 4       # 预取窗口
  readAheadChunks: 8      # 预取 Chunk 数

文件大小：50GB
单线程顺序读：2GB/s
16 路并行读：12GB/s（接近线速的 80%+）

network:
  transport: "rdma"      # tcp（默认）/ rdma
rdma:
  device: "mlx5_0"       # InfiniBand/RoCE 设备
  gidIndex: 1            # GID 索引
  mtu: "4096"            # MTU 大小
  queueDepth: 1024       # 队列深度

**性能对比：**
| 传输模式 | 4K 读延迟 | 吞吐量 | CPU 利用率 |
|---------|----------|--------|-----------|
| TCP | 50μs | 20Gbps | 60% |
| RDMA | 5μs | 56Gbps | 10% |

# 批量获取目录下的 inode 信息
# 一次 RPC 获取整个目录（10000 文件）的元数据
rustfs meta batch-getattr /data/images --limit 10000

# 批量设置属性（权限、时间戳）
rustfs meta batch-setattr /data/archive --atime 2026-01-01

# 原子交换两个文件路径
rustfs meta rename-exchange /data/current/config.yaml \
  /data/new/config.yaml

# 安装 FUSE 客户端
apt install rustfs-client

# 挂载文件系统
mount -t rustfs meta-cluster:9500 /mnt/rustfs \
  -o noatime,allow_other

# /etc/fstab 自动挂载
meta-cluster:9500  /mnt/rustfs  rustfs  defaults,noatime  0  0

# 使用内核模块挂载（性能优于 FUSE）
modprobe rustfs
mount -t rustfs meta-cluster:9500 /mnt/rustfs

# 生产集群配置
cluster:
  metaServers: 3
  dataServers: 3
  replicaCount: 3
  placementStrategy: host_aware
  
meta:
  memory: 32Gi
  cpu: 8
  storage: "ssd"
  
data:
  memory: 64Gi
  cpu: 16
  diskPerNode: "4x 3.84TB NVMe"
  network: "25GbE"