Curvine 作为一款高性能分布式缓存系统，对性能、稳定性和可靠性有着严苛的要求。 为确保系统在各种负载条件下保持最优性能，并快速定位和解决潜在问题，我们构建了基于 Prometheus 和 Grafana 的全方位监控解决方案。该监控体系为 Master 节点、Worker 节点、Fuse 节点和 S3 Gateway 提供深度可观测性能力，通过收集各组件的关键指标，实现对缓存集群规模、运行状态、性能表现和资源使用情况的实时监控。

监控架构​

本监控系统采用以下核心组件：

• Prometheus: 负责指标收集、存储和查询
• Grafana: 提供数据可视化和仪表板展示

可观测性指标​

Master 节点指标​

Master 节点作为集群的元数据管理中心，提供以下关键指标：

容量指标​

容量指标是评估系统存储资源使用状况的基础，对容量规划、资源优化和预防性维护至关重要。通过监控这些指标，可以及时发现存储瓶颈，预测容量需求，确保系统有足够空间应对业务增长。

资源指标​

资源指标反映了系统对计算资源的使用情况，对性能调优、资源分配和故障预防具有重要意义。内存使用情况直接影响系统性能和稳定性，特别是 RocksDB 作为核心存储引擎，其内存占用需要精确监控以避免内存溢出和性能下降。

集群状态指标​

集群状态指标提供了系统整体健康状况的实时视图，对保障高可用性和数据一致性至关重要。通过监控 Worker 节点状态和复制任务执行情况，可以快速发现节点故障、数据不一致等问题，确保分布式缓存系统的可靠运行。

性能指标​

性能指标是衡量系统响应能力和处理效率的核心指标，对性能优化和容量规划具有关键作用。RPC 请求的总计数和总耗时可以计算出平均响应时间，直接反映系统的处理能力，而各类操作的耗时分析有助于识别性能瓶颈，指导系统优化。

Journal 系统指标​

Journal 系统是保证数据一致性和故障恢复的关键组件，其性能直接影响系统的写入性能和数据可靠性。监控 Journal 队列长度和刷新性能可以及时发现写入瓶颈，预防数据丢失风险，确保系统在高并发写入场景下的稳定性。

Client 指标（Fuse/S3 Gateway）​

Fuse 和 S3 Gateway 的指标通过 Client 收集

缓存指标​

缓存指标直接反映了缓存系统的核心价值——提升访问性能。挂载缓存的命中率是衡量缓存效果的关键指标，高命中率意味着更少的后端访问和更快的响应速度。这些指标对评估缓存策略有效性、优化缓存配置至关重要。

I/O 指标​

I/O 指标是评估系统读写性能的核心数据，对性能调优和容量规划具有指导意义。通过监控读写字节数和耗时，可以计算出读写吞吐量，准确评估系统的 I/O 性能瓶颈，优化存储策略，确保在高并发访问场景下的稳定性能。

元数据操作指标​

元数据操作性能直接影响文件系统的响应速度，对提升用户体验和系统整体性能至关重要。元数据操作的耗时分析有助于识别元数据管理瓶颈，优化目录结构，提升文件系统操作效率。

Worker 节点指标​

Worker 节点作为数据存储节点，提供全面的存储和性能指标：

容量指标​

Worker 节点的容量指标是数据存储管理的核心，对负载均衡、数据迁移和容量规划具有关键作用。通过监控各节点的存储使用情况，可以实现智能的数据分布，防止单点过载，确保整个缓存集群的存储资源得到最优利用。

I/O 指标​

Worker 节点的 I/O 指标反映了数据存储的实际性能，对评估存储硬件效率、优化数据访问模式至关重要。详细的读写统计信息有助于识别热点数据、优化数据布局，提升整体存储性能和响应速度。

资源指标​

Worker 节点的资源使用情况直接影响数据存储服务的稳定性和性能，对资源调度和性能优化具有重要意义。合理的内存使用是保证数据缓存效率的基础，需要精确监控以避免资源竞争和性能下降。

硬件状态指标​

硬件状态指标是保障数据可靠性和系统可用性的重要监控维度，对预防性维护和故障快速响应至关重要。通过实时监控磁盘健康状态，可以提前发现硬件故障风险，及时进行数据迁移和硬件更换，确保缓存系统的数据安全和持续可用。

全局面板​

Master​

Worker​

Client​

总结​

Curvine 分布式缓存系统的可观测性设计覆盖了从元数据管理到数据存储的完整链路，通过细粒度的指标收集实现了：

• 全链路监控: 从客户端请求到数据存储的完整监控，确保每个环节的性能和状态都可观测
• 多维度观测: 涵盖性能、容量、状态等多个维度，提供系统健康度的全面视图
• 实时告警: 基于关键指标的实时监控和告警，及时发现异常并快速响应
• 故障诊断: 详细的指标数据支持快速故障定位，缩短故障恢复时间
• 性能优化: 通过持续监控和分析，为系统性能调优提供数据支撑
• 容量规划: 基于历史趋势和实时数据，为容量扩展和资源优化提供决策依据

通过这套完善的监控体系，Curvine 能够在复杂的分布式环境中保持高可用性和高性能，为用户提供稳定可靠的缓存服务。

📚 目录​

• 🎯 系统概述
• 📂 路径挂载管理
• 💾 智能缓存策略
• 🔄 数据一致性保障
• 🤖 AI/ML 场景应用
• 🗄️ 大数据生态集成
• 💡 最佳实践
• 🎯 总结

🎯 系统概述​

Curvine 是一个高性能、云原生的分布式缓存系统，专为现代数据密集型应用设计。它在底层存储（UFS）和计算引擎之间提供一个智能缓存层，显著提升数据访问性能。

🏆 性能优势​

相比传统存储访问方式，Curvine 可以提供：

核心组件​

• Master 集群: 元数据管理、缓存调度、一致性保障
• Worker 节点: 数据缓存、I/O 处理、任务执行
• Client SDK: 多语言客户端，支持Rust、Fuse、Java、Python
• Job Manager: 分布式任务调度和管理
• Metrics 系统: 实时监控和性能分析

📂 路径挂载管理​

挂载是使用 Curvine 缓存的第一步，它建立了底层存储（UFS）与缓存路径的映射关系。

挂载模式详解​

Curvine 支持两种灵活的挂载模式：

🎯 CST 模式（一致路径模式）​

# 路径保持一致，便于管理和维护
bin/cv mount s3://bucket/data /bucket/data --mnt-type cst

适用场景:

• 路径结构清晰的数据湖场景
• 需要直观路径映射的生产环境
• 多团队协作的数据平台

🔀 Arch 模式（编排模式）​

# 灵活路径映射，支持复杂的路径变换
bin/cv mount s3://complex-bucket/deep/nested/path /simple/data --mnt-type arch

适用场景:

• 复杂的存储层次结构
• 需要路径抽象的场景
• 多云存储统一访问

完整挂载示例​

# 挂载 S3 存储到 Curvine（生产级配置）
bin/cv mount \
s3://bucket/warehouse/tpch_500g.db/orders \
/bucket/warehouse/tpch_500g.db/orders \
--ttl-ms 24h \
--ttl-action delete \
--replicas 3 \
--block-size 128MB \
--consistency-strategy always \
--storage-type ssd \
-c s3.endpoint_url=https://s3.ap-southeast-1.amazonaws.com \
-c s3.credentials.access=access_key \
-c s3.credentials.secret=secret_key \
-c s3.region_name=ap-southeast-1 

挂载参数详解​

挂载点管理​

# 查看所有挂载点
bin/cv mount

# 卸载路径
bin/cv unmount /bucket/warehouse/tpch_500g.db/orders

💾 智能缓存策略​

Curvine 提供多种智能缓存策略，从被动响应到主动预测，全方位优化数据访问性能。

主动数据预加载​

主动加载让您可以在业务高峰前预热缓存，确保最佳性能：

# 基础加载
bin/cv load s3:/bucket/warehouse/critical-dataset

# 带进度监控的同步加载
bin/cv load s3:/bucket/warehouse/critical-dataset -w

自动缓存策略​

Curvine 的自动缓存系统相比传统方案具有显著优势：

✨ Curvine 智能缓存架构​

核心优势对比​

🔄 数据一致性保障​

数据一致性是缓存系统的核心挑战，Curvine 提供多层次的一致性保障机制。

一致性策略详解​

1. 🚫 None 模式 - 最高性能​

bin/cv mount s3://bucket/path /bucket/path --consistency-strategy=none

• 适用场景: 静态数据、归档数据、只读数据集
• 性能: ⭐⭐⭐⭐⭐ (最快)
• 一致性: ⭐⭐ (依赖TTL)

2. ✅ Always 模式 - 强一致性​

bin/cv mount s3://bucket/path /bucket/path --consistency-strategy=always

• 适用场景: 经常更新的业务数据、关键业务系统
• 性能: ⭐⭐⭐ (有开销)
• 一致性: ⭐⭐⭐⭐⭐ (强一致性)

3. 🕰️ Period 模式 - 平衡方案​

bin/cv mount s3://bucket/path /bucket/path \
  --consistency-strategy=period \
  --check-interval=5m

• 适用场景: 更新频率可预期的数据
• 性能: ⭐⭐⭐⭐ (较好)
• 一致性: ⭐⭐⭐⭐ (定期保证)

缓存性能监控​

监控缓存命中率是评估一致性策略效果的重要手段：

# 获取缓存命中率
curl -s http://master:9001/metrics | grep -E "(cache_hits|cache_misses)"

client_mount_cache_hits{id="3108497238"} 823307
client_mount_cache_misses{id="3108497238"} 4380

🤖 AI/ML 场景应用​

AI 和机器学习工作负载对存储性能有极高要求，Curvine 为此提供了专门优化的功能。

深度学习训练优化​

# 为 GPU 集群优化的数据加载
bin/cv mount s3://datasets/imagenet /datasets/imagenet \
  --storage-type=mem \
  --block-size=1GB \
  --replicas=2 \

模型服务场景​

# 模型文件缓存（低延迟访问）
bin/cv mount s3://model/bert-large /models/bert-large \
  --storage-type=mem \
  --ttl-ms=none \
  --consistency-strategy=always \

# 推理数据缓存
bin/cv mount s3://inference/input /inference/input \
  --storage-type=ssd \
  --ttl-ms=1h \
  --consistency-strategy=none 

🔗 POSIX 语义与 FUSE 访问​

Curvine 完美支持 POSIX 语义，通过 FUSE（Filesystem in Userspace）接口，可以将 Curvine 集群挂载为本地文件系统，为 AI/ML 应用提供透明的文件访问体验。

AI/ML 训练中的 FUSE 使用​

1. 深度学习训练数据访问​

# PyTorch 训练脚本
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os

class CurvineImageDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        """
        通过 FUSE 挂载点直接访问 Curvine 中的数据
        root_dir: FUSE 挂载点路径，如 /curvine-fuse/datasets/imagenet
        """
        self.root_dir = root_dir
        self.transform = transform
        self.image_paths = []
        
        # 直接遍历 FUSE 挂载的目录
        for class_dir in os.listdir(root_dir):
            class_path = os.path.join(root_dir, class_dir)
            if os.path.isdir(class_path):
                for img_file in os.listdir(class_path):
                    if img_file.lower().endswith(('.png', '.jpg', '.jpeg')):
                        self.image_paths.append(os.path.join(class_path, img_file))
    
    def __len__(self):
        return len(self.image_paths)
    
    def __getitem__(self, idx):
        # 通过标准文件操作访问数据，享受 Curvine 缓存加速
        img_path = self.image_paths[idx]
        image = Image.open(img_path).convert('RGB')
        
        if self.transform:
            image = self.transform(image)
            
        # 从路径提取标签
        label = os.path.basename(os.path.dirname(img_path))
        return image, label

# 使用示例
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                        std=[0.229, 0.224, 0.225])
])

# 直接使用 FUSE 挂载点的路径
dataset = CurvineImageDataset(
    root_dir='/curvine-fuse/datasets/imagenet/train',
    transform=transform
)

dataloader = DataLoader(
    dataset, 
    batch_size=64, 
    shuffle=True, 
    num_workers=8,
    pin_memory=True
)

# 训练循环
for epoch in range(num_epochs):
    for batch_idx, (data, targets) in enumerate(dataloader):
        # 数据通过 FUSE 自动从 Curvine 缓存加载
        # 享受接近内存的访问速度
        outputs = model(data.cuda())
        loss = criterion(outputs, targets.cuda())
        # ... 训练逻辑

2. TensorFlow/Keras 数据管道​

import tensorflow as tf
import os

def create_curvine_dataset(data_dir, batch_size=32):
    """
    通过 FUSE 挂载点创建 TensorFlow 数据管道
    data_dir: FUSE 挂载的数据目录
    """
    
    # 直接使用标准文件 API 访问 FUSE 挂载的数据
    def load_and_preprocess_image(path):
        # TensorFlow 通过 FUSE 透明访问 Curvine 缓存
        image = tf.io.read_file(path)
        image = tf.image.decode_jpeg(image, channels=3)
        image = tf.image.resize(image, [224, 224])
        image = tf.cast(image, tf.float32) / 255.0
        return image
    
    # 扫描 FUSE 挂载目录中的文件
    image_paths = []
    labels = []
    
    for class_name in os.listdir(data_dir):
        class_dir = os.path.join(data_dir, class_name)
        if os.path.isdir(class_dir):
            for img_file in os.listdir(class_dir):
                if img_file.lower().endswith(('.png', '.jpg', '.jpeg')):
                    image_paths.append(os.path.join(class_dir, img_file))
                    labels.append(class_name)
    
    # 创建数据集
    path_ds = tf.data.Dataset.from_tensor_slices(image_paths)
    label_ds = tf.data.Dataset.from_tensor_slices(labels)
    
    # 应用预处理
    image_ds = path_ds.map(
        load_and_preprocess_image, 
        num_parallel_calls=tf.data.AUTOTUNE
    )
    
    # 组合数据和标签
    dataset = tf.data.Dataset.zip((image_ds, label_ds))
    
    return dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)

# 使用示例
train_dataset = create_curvine_dataset('/curvine-fuse/datasets/imagenet/train')
val_dataset = create_curvine_dataset('/curvine-fuse/datasets/imagenet/val')

# 模型训练
model.fit(
    train_dataset,
    validation_data=val_dataset,
    epochs=50,
    callbacks=[
        tf.keras.callbacks.ModelCheckpoint('/curvine-fuse/models/checkpoints/'),
        tf.keras.callbacks.TensorBoard(log_dir='/curvine-fuse/logs/')
    ]
)

🗄️ 大数据生态集成​

Curvine 与主流大数据框架无缝集成，提供透明的缓存加速能力。

Hadoop 生态集成​

基础配置​

在 hdfs-site.xml 或 core-site.xml 中添加：

<!-- Curvine FileSystem 实现 -->
<property>
    <name>fs.cv.impl</name>
    <value>io.curvine.CurvineFileSystem</value>
</property>

<!-- 单集群配置 -->
<property>
    <name>fs.cv.master_addrs</name>
    <value>master1:8995,master2:8995,master3:8995</value>
</property>

多集群支持​

<!-- 集群1：生产环境 -->
<property>
    <name>fs.cv.production.master_addrs</name>
    <value>prod-master1:8995,prod-master2:8995,prod-master3:8995</value>
</property>

<!-- 集群2：开发环境 -->
<property>
    <name>fs.cv.development.master_addrs</name>
    <value>dev-master1:8995,dev-master2:8995</value>
</property>

<!-- 集群3：机器学习专用集群 -->
<property>
    <name>fs.cv.ml-cluster.master_addrs</name>
    <value>ml-master1:8995,ml-master2:8995,ml-master3:8995</value>
</property>

🔄 UFS透明代理​

为了更好地支持现有Java应用无缝接入Curvine缓存，我们提供了UFS透明代理解决方案。该方案的核心优势是零代码修改，让现有应用可以立即享受Curvine的缓存加速效果。

✨ 透明代理核心特性​

• 🚫 零代码修改: 保留原有所有接口不变，业务代码无需任何修改
• 🔍 智能路径识别: 仅在文件打开时判断路径是否已挂载到Curvine
• ⚡ 自动缓存加速: 已挂载路径自动启用缓存加速，未挂载路径走原生S3访问
• 🔄 平滑切换: 支持在运行时动态切换是否使用缓存，无需重启应用

🛠️ 配置方式​

只需要替换Hadoop配置中的S3FileSystem实现类：

<!-- 传统S3访问配置 -->
<!--
<property>
    <name>fs.s3a.impl</name>
    <value>org.apache.hadoop.fs.s3a.S3AFileSystem</value>
</property>
-->

<!-- 替换为Curvine透明代理 -->
<property>
    <name>fs.s3a.impl</name>
    <value>io.curvine.S3AProxyFileSystem</value>
</property>

<property>
    <name>fs.cv.impl</name>
    <value>io.curvine.CurvineFileSystem</value>
</property>

<!-- Curvine集群配置 -->
<property>
    <name>fs.curvine.master_addrs</name>
    <value>master1:8995,master2:8995,master3:8995</value>
</property>

🔧 工作原理​

🚀 使用示例​

无需修改任何业务代码，原有代码直接享受加速：

// 业务代码完全不变！
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get(URI.create("s3a://my-bucket/"), conf);

// 这个路径如果已挂载到Curvine，自动享受缓存加速
FSDataInputStream input = fs.open(new Path("s3a://my-bucket/warehouse/data.parquet"));

// 这个路径如果未挂载，走原生S3访问
FSDataInputStream input2 = fs.open(new Path("s3a://my-bucket/archive/old-data.parquet"));

Spark/MapReduce代码示例：

// Spark代码无需任何修改
Dataset<Row> df = spark.read()
    .option("header", "true")
    // 如果/warehouse/路径已挂载，自动使用缓存加速
    .csv("s3a://data-lake/warehouse/customer_data/");
    
df.groupBy("region")
  .agg(sum("revenue").alias("total_revenue"))
  .orderBy(desc("total_revenue"))
  .show(20);

Python PySpark示例：

# Python代码也无需修改
from pyspark.sql import SparkSession
from pyspark.sql.functions import sum, desc

spark = SparkSession.builder.appName("TransparentCache").getOrCreate()

# 自动判断是否使用缓存
df = spark.read \
    .option("header", "true") \
    .csv("s3a://data-lake/analytics/events/")

result = df.groupBy("event_type") \
    .agg(sum("count").alias("total_events")) \
    .orderBy(desc("total_events"))
    
result.show()

Apache Spark 优化配置​

# Spark 应用启动配置
spark-submit \
  --class com.example.SparkApp \
  --master yarn \
  --deploy-mode cluster \
  --conf spark.hadoop.fs.cv.impl=io.curvine.CurvineFileSystem \
  --conf spark.hadoop.fs.cv.master_addrs=master1:8995,master2:8995,master3:8995 \
  --conf spark.sql.adaptive.enabled=true \
  --jars curvine-hadoop-client.jar \
  app.jar

Spark 代码示例​

// Scala 示例
val spark = SparkSession.builder()
  .appName("Curvine Demo")
  .config("spark.hadoop.fs.cv.impl", "io.curvine.CurvineFileSystem")
  .getOrCreate()

// 直接使用 cv:// 协议访问缓存数据
val df = spark.read
  .option("multiline", "true")
  .json("cv://production/warehouse/events/2024/01/01/")

df.groupBy("event_type")
  .count()
  .show()

// 多集群访问
val prodData = spark.read.parquet("cv://production/warehouse/sales/")
val mlData = spark.read.parquet("cv://ml-cluster/features/user_profiles/")

# Python 示例
from pyspark.sql import SparkSession

spark = SparkSession.builder \
    .appName("Curvine Python Demo") \
    .config("spark.hadoop.fs.cv.impl", "io.curvine.CurvineFileSystem") \
    .config("spark.hadoop.fs.cv.master_addrs", "master1:8995,master2:8995") \
    .getOrCreate()

# 读取缓存中的数据
df = spark.read.option("header", "true") \
    .csv("cv://warehouse/customer_data/")

# 复杂查询自动享受缓存加速
result = df.groupBy("region") \
    .agg({"revenue": "sum", "orders": "count"}) \
    .orderBy("sum(revenue)", ascending=False)

result.show(20)

Trino/Presto 插件集成​

Curvine 提供了智能路径替换插件，可以做到无侵入性实现缓存加速，不需要业务修改代码，实现完全透明的缓存加速：

插件工作流程​

spark 插件使用实例：

spark-submit \
--class main.scala.Tpch \
--name tpch_demo \
--conf spark.hadoop.fs.cv.impl=io.curvine.CurvineFileSystem \
--conf spark.hadoop.fs.cv.default.master_addrs=master1:8995,master2:8995 \
--conf spark.sql.extensions=io.curvine.spark.CurvineSparkExtension \

Flink 实时计算集成​

// Flink Table API 集成示例
TableEnvironment tableEnv = TableEnvironment.create(settings);

// 配置 Curvine FileSystem
Configuration config = new Configuration();
config.setString("fs.cv.impl", "io.curvine.CurvineFileSystem");
config.setString("fs.cv.master_addrs", "master1:8995,master2:8995");

// 创建 Curvine 表
tableEnv.executeSql(
    "CREATE TABLE user_events (" +
    "  user_id BIGINT," +
    "  event_type STRING," +
    "  timestamp_ms BIGINT," +
    "  properties MAP<STRING, STRING>" +
    ") WITH (" +
    "  'connector' = 'filesystem'," +
    "  'path' = 'cv://streaming/events/'," +
    "  'format' = 'json'" +
    ")"
);

// 实时查询享受缓存加速
Table result = tableEnv.sqlQuery(
    "SELECT user_id, COUNT(*) as event_count " +
    "FROM user_events " +
    "WHERE timestamp_ms > UNIX_TIMESTAMP() * 1000 - 3600000 " +
    "GROUP BY user_id"
);

💡 最佳实践​

🎯 挂载策略最佳实践​

按业务场景分层挂载​

# 热数据：高频访问，使用内存缓存
bin/cv mount s3://bucket/hot /bucket/hot \
  --storage-type=mem \
  --replicas=3 \
  --ttl-ms=1d \
  --ttl-action=delete

# 温数据：定期访问，使用 SSD 缓存
bin/cv mount s3://bucket/warm /bucket/warm \
  --storage-type=ssd \
  --replicas=2 \
  --ttl-ms=7d \
  --ttl-action=delete


# 冷数据：低频访问，使用磁盘缓存
bin/cv mount s3://bucket/cold /bucket/cold \
  --storage-type=disk \
  --replicas=1 \
  --ttl-ms=30d \
  --ttl-action=delete

按数据类型优化​

# 小文件密集型（如日志、配置）
bin/cv mount s3://bucket/logs /bucket/logs \
  --block-size=4MB \
  --consistency-strategy=none \

# 大文件型（如视频、模型）
bin/cv mount s3://bucket/models /bucket/models \
  --block-size=1GB \
  --consistency-strategy=always \

# 分析型数据（如 Parquet）
bin/cv mount s3://bucket/analytics /bucket/analytics \
  --block-size=128MB \
  --consistency-strategy=none \

🎯 总结​

Curvine 作为新一代分布式缓存系统，通过智能缓存策略、强一致性保障和无缝生态集成，为现代数据密集型应用提供了卓越的性能提升。

🏆 核心价值​

• 🚀 性能提升: 10-100倍的访问加速，显著降低数据访问延迟
• 💰 成本优化: 减少云存储访问费用，提高计算资源利用率
• 🛡️ 数据安全: 多重一致性保障，确保数据准确性和完整性
• 🌐 生态友好: 与主流大数据和 AI 框架无缝集成

Curvine - 让数据访问快如闪电 ⚡

如何快速上手试试Curvine的效果？这篇文章将介绍如何从0到1构建一个本地小集群，让大家快速上手。

github： https://github.com/CurvineIO/curvine

1. 下载代码：​

git clone https://github.com/CurvineIO/curvine.git

2.环境要求：​

GCC: version 10 or later 
Rust: version 1.86 or later 
Protobuf: version 3.x
Maven: version 3.8 or later
LLVM: version 12 or later
FUSE: libfuse2 or libfuse3 development packages
JDK: version 1.8 or later 
npm: version 9 or later
Python: version 3.7 or later 

参考

3. 编译&&运行​

make all

为方便大家编译，我们做编译脚本里会提前做依赖组件检查，对于MacOS系统的用户，暂时会选择跳过FUSE的编译（目前没适配mac系统）。 感兴趣的朋友可以考虑使用macfuse项目，进行适配。

4.编译完成，启动本地集群​

cd build/dist
./bin/restart-all.sh

启动成功后，执行report命令，检查是否成功：

bin/cv report

       active_master: localhost:8995
       journal_nodes: 1,localhost:8996
            capacity: 233.5GB
           available: 105.0GB (44.99%)
             fs_used: 0.0B (0.00%)
         non_fs_used: 128.4GB
     live_worker_num: 1
     lost_worker_num: 0
           inode_num: 0
           block_num: 0
    live_worker_list: 192.168.xxx.xxx:8997,105.0GB/233.5GB (44.99%)
    lost_worker_list:

5. 查看本地master和worker的webui​

http://localhost:9000/
http://localhost:9001/

6. FIO测试​

测试环境：阿里云 ecs.r8a.8xlarge 机型 master/woker/client 各一台

• 32 核（vCPU）
• 256 GiB 内存
• 系统盘 和 数据盘 均为：ESSD 云盘 500 GiB(7800 IOPS)
• 最大带宽：25Gb

准备数据（在worker机器）：

bin/curvine-bench.sh fuse.write

fio顺序读测试，8并发

fio -iodepth=1 -rw=read -ioengine=libaio -bs=256k
 -group_reporting -size=200gb 
 -filename=/curvine-fuse/fs-bench/0  
 -name=read_test --readonly -direct=1 --runtime=60 
 -numjobs=8

fio随机读测试，8并发

fio -iodepth=1 -rw=randread -ioengine=libaio -bs=256k
 -group_reporting -size=200gb 
 -filename=/curvine-fuse/fs-bench/0  
 -name=read_test --readonly -direct=1 --runtime=60
 -numjobs=8

最后，视频演示一下，做一下fio测试的效果：

Curvine是什么​

 Curvine是一套分布式缓存系统，基于Rust实现，具备 高并发，高吞吐，低延迟，资源消耗低等特点。不同于Redis、TiKV等KV缓存，Curvine只提供文件缓存能力。Curvine不是存储系统，只提供缓存能力，数据持久化还是需要底层文件或者对象存储系统支撑。

解决什么问题​

1. 大规模数据IO性能瓶颈
2. 单机缓存系统容量瓶颈

实际应用中，有哪些场景适用Curvine加速？

Fig. 1：Curvine Application Scenarios.

如上图所示，Curvine适用于以下五大场景：

1. 大数据shuffle 中间数据加速
2. 大数据热表数据缓存加速
3. AI训练数据缓存加速
4. 模型文件分发缓存加速
5. 多云数据缓存，解决跨云专线性能瓶颈

以上场景总结，只是抛砖引玉，通俗的理解，Curvine其实就是解决： 日益增长的计算性能需求与分布式存储系统的IO能力瓶颈的矛盾。

性能表现​

我们从以下几个方面展示性能和资源使用情况：

1. 元数据操作性能

 注： 对比数据选取的并发度均为40

 详细结果： https://curvineio.github.io/docs/Benchmark/meta/

 业界类似产品测试数据：https://juicefs.com/zh-cn/blog/engineering/meta-perf-hdfs-oss-jfs

2. 数据读写性能

相同硬件条件下，测试对比Alluxio性能：

● 256k顺序读

● 256k随机读

  Alluxio官网数据披露：https://www.alluxio.com.cn/alluxio-enterprise-vs-open-source/

3. 资源消耗情况

  得益于Rust语言的特性，我们在大数据shuffle加速场景下，对比线上使用Curvine和Alluxio资源消耗情况，内存降低90%+，cpu降低50%+。

架构简介​

 Curvine架构设计理念：简单、极致、通用。

Fig. 2：Curvine Application Scenarios.

 简单：简单轻量，缓存服务只有两个角色：master、worker。非性能瓶颈的模块，尽量复用开源或者已有的技术，代码最大可能轻量化。

 极致：对性能影响较大的关键节点：底层rpc通信架构、Fuse 实现性能等关键组件，自主设计实现，以极致性能优化思维构建。

 通用:：兼容多种现有接入模式，底层存储兼容主流分布式文件和对象存储做到足够通用，易用。

关于开源​

 我们在内部大数据高并发高吞吐场景下使用Curvine加速数据IO，取得比较大的收益。希望吸引外部的伙伴共同建设，一起加速基础设施向Rust转变。  https://github.com/curvineio/curvine

  由OPPO大数据提供支持。