rocksdb简介#

RocksDB是Facebook的一个实验项目，目的是希望能开发一套能在服务器压力下，真正发挥高速存储硬件（特别是Flash存储）性能的高效数据库系统。这是一个C++库，允许存储任意长度二进制kv数据。支持原子读写操作。

RocksDB依靠大量灵活的配置，使之能针对不同的生产环境进行调优，包括直接使用内存，使用Flash，使用硬盘或者HDFS。支持使用不同的压缩算法，并且有一套完整的工具供生产和调试使用。

离线生成sst的意义#

我们有亿级别的kv数据， 原来是存储在mongodb中，存储满了后，扩容较难，并且每天增量的大数据量写入会影响现网性能，我们考虑每天增量的数据可以离线写好生成一个数据文件，线上的kv系统能直接load这个文件。

可以根据预估的数据量，提前计算好需要多少shard，大数据平台可以根据id将数据hash分片，离线生成好分片数据，查询时，根据查询id，计算在那个分片，然后路由服务路由到对应分片去查询。

这样的好处：

• 数据文件可以有版本，在多套环境时，只要加载的数据文件一致，数据就一致
• 扩容方便，当服务器资源不够时，直接增加服务器，加载新的分片并将新启动的服务注册到配置中心即可
• 数据写入都是离线写入好的，不会影响线上的读取

当然，对于需要实时写入的数据，会稍微麻烦点，我们可以考虑Plain+rt方案，提供一个在线实时写入的小库，这样查询时两个一起查询即可，小库可以定期刷入大库。

rocksdb 可以离线生成好sst文件，将sst文件拷贝到现网，导入SST文件即可，并且新的sst里会覆盖老的同key数据，正好符合我们的需求。

java 生成sst文件#

需要先引入maven依赖

Copy
<dependency>  
    <groupId>org.rocksdb</groupId>  
    <artifactId>rocksdbjni</artifactId>  
    <version>8.8.1</version>  
</dependency>

然后通过SstFileWriter 创建sst文件写入即可，需要注意的是，写入时，Keys must be added in strict ascending order. key需要严格遵循字节序。

我们写一个程序从mongodb读取数据，并写入sst。可以先读取出id，然后按字符串排序。

Copy
// SST 写入，需要按照id排序 Keys must be added in strict ascending order.
Query query = new Query();  
query.fields().include("_id");  
CloseableIterator<Document> dataList = mongoTemplate.stream(query, Document.class, collectionName);

List<String> docIds = new ArrayList<>();  
log.info("start load ids");  
while (dataList.hasNext()) {  
    Document doc = dataList.next();  
    docIds.add(doc.get("_id").toString());  
}  
log.info("load ids finish, start sort id");  
docIds = docIds.stream().sorted().collect(Collectors.toList());

然后根据id从mongo读取数据，写入sst

Copy


Path sstFile = Paths.get(outputFile);  
EnvOptions env = new EnvOptions();  
Options options = new Options();  
options.setCompressionType(CompressionType.ZSTD_COMPRESSION);  
//        options.setComparator(new MyComparator(new ComparatorOptions()));  
SstFileWriter sst = new SstFileWriter(env, options);  
sst.open(sstFile.toString());  
int count = 0;  
int batchSize = 100;  
int batchCount = docIds.size() / batchSize + 1;  
log.info("batch count is {}", batchCount);  
for (int i = 0; i < batchCount; i++) {  
	if (i * batchCount >= docIds.size()) {  
		break;  
	}  
	List<Long> batchIds = docIds.subList(i * batchCount, Math.min(docIds.size() - 1, (i + 1) * batchCount))  
			.stream().map(Long::parseLong).collect(Collectors.toList());  
	List<Document> batchDocs = mongoTemplate.find(Query.query(Criteria.where("_id").in(batchIds)),  
			Document.class, collectionName);  
	Map<String, Document> docId2Doc = batchDocs.stream().collect(Collectors.toMap(doc -> doc.get("_id").toString(), doc -> doc));  

	for (Long id : batchIds) {  
		String docId = id.toString();  
		Document doc = docId2Doc.get(docId);  
		byte[] value = doc.toJson().getBytes(StandardCharsets.UTF_8);  
		sst.put(docId.getBytes(StandardCharsets.UTF_8), value);  
	}  

	count += batchIds.size();  
	if (count % 10000 == 0) {  
		log.info("already load {} items", count);  
	}  
}  
// 注意一定要finish
sst.finish();  
sst.close();

PS ： 上面我们遵循了字节序，如果不想遵循，可以自定义Comparator

Copy
class MyComparator extends AbstractComparator {  
  
    protected MyComparator(ComparatorOptions comparatorOptions) {  
        super(comparatorOptions);  
    }  
  
    @Override  
    public String name() {  
        return "MyComparator";  
    }  
  
    @Override  
    public int compare(ByteBuffer byteBuffer, ByteBuffer byteBuffer1) {  
        // always true  
        return 1;  
    }  
}


Options options = new Options();  
options.setCompressionType(CompressionType.ZSTD_COMPRESSION);  
// 使用自定义
options.setComparator(new MyComparator(new ComparatorOptions()));

java 加载sst#

可以通过ingestExternalFile 加载sst文件

Copy
private static void read(String[] args) {  
  
    String dbFile = args[1];  
    String sstFile = args[2];  
  
  
    // a static method that loads the RocksDB C++ library.  
    RocksDB.loadLibrary();  
  
    // the Options class contains a set of configurable DB options  
    // that determines the behaviour of the database.    try (final Options options = new Options().setCreateIfMissing(true)) {  
  
        options.setCompressionType(CompressionType.ZSTD_COMPRESSION);  
  
        // a factory method that returns a RocksDB instance  
        try (final RocksDB db = RocksDB.open(options, dbFile)) {  
            db.ingestExternalFile(Collections.singletonList(sstFile),new IngestExternalFileOptions());  
  
            while(true) {  
                System.out.print("请输入查询key:");  
                String key =  System.console().readLine();  
                byte[] result = db.get(key.getBytes(StandardCharsets.UTF_8));  
                if (result != null) {  
                    System.out.println(new String(result));  
                }  
            }  
        }  
  
  
    } catch (RocksDBException e) {  
        // do some error handling  
        e.printStackTrace();  
    }  
}

golang 加载java生成好的sst#

我们已经有一个golang开发的分布式框架，因此可以java在大数据平台生成好sst文件，传输到现网供go服务load。

golang使用rocksdb，可以使用 "github.com/linxGnu/grocksdb"，需要先编译相关依赖，可以用仓库中的makefile，make安装rocksdb等依赖。

然后编译读取程序：

Copy
package main

import (
	"fmt"
	"os"
	"time"
	
	"github.com/linxGnu/grocksdb"
)

func main() {

	arg := os.Args
	if len(arg) < 3 {
		fmt.Println("Please provide a directory to store the database")
		return
	}

	dir := arg[1]
	fmt.Printf("db dir is %s \n", dir)
	sstFile := arg[2]
	fmt.Printf("sst file is %s \n", sstFile)
	opts := grocksdb.NewDefaultOptions()
	// test the ratelimiter
	rateLimiter := grocksdb.NewRateLimiter(1024, 100*1000, 10)
	opts.SetRateLimiter(rateLimiter)
	opts.SetCreateIfMissing(true)
	// 默认是Snappy。我们相信LZ4总是比Snappy好的。我们之所以把Snappy作为默认的压缩方法，是为了与之前的用户保持兼容。LZ4/Snappy是轻量压缩，所以在CPU使用率和存储空间之间能取得一个较好的平衡
	// 如果你有大量空闲CPU并且希望同时减少空间和写放大，把options.compression设置为重量级的压缩方法。我们推荐ZSTD，如果没有就用Zlib
	opts.SetCompression(grocksdb.ZSTDCompression)
	db, _ := grocksdb.OpenDb(opts, dir)

	// db.EnableManualCompaction()
	// db.DisableManualCompaction()

	defer db.Close()

	// 合并数据
	ingestOpts := grocksdb.NewDefaultIngestExternalFileOptions()

	err := db.IngestExternalFile([]string{sstFile}, ingestOpts)
	if err != nil {
		fmt.Println("Error ingesting external file:", err)
		return
	}

	fmt.Println("finish IngestExternalFile", time.Now())
	readOpts := grocksdb.NewDefaultReadOptions()

	for {
		var input string
		fmt.Println("请输入一个查询key：")
		fmt.Scanln(&input)
		if input == "exit" {
			return
		}
		v1, err := db.Get(readOpts, []byte(input))
		if err != nil {
			fmt.Println("read key error", err)
			continue
		}
		fmt.Println("value = ", string(v1.Data()))

	}
}

编译时，指定下rocksdb库的位置。

Copy
CGO_CFLAGS="-I/data/grocksdb-1.8.10/dist/linux_amd64/include" CGO_LDFLAGS="-L/data/grocksdb-1.8.10/dist/linux_amd64/lib -lrocksdb -lstdc++ -lm -lz -lsnappy -llz4 -lzstd"   go build -o load_sst_demo ./load_sst_demo.go

关注作者

欢迎关注作者微信公众号, 一起交流软件开发：