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依赖
<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，然后按字符串排序。
// 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
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
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文件
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等依赖。
然后编译读取程序：
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库的位置。
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