golang分布式高性能键值存储插件库Vasto的使用

Golang分布式高性能键值存储插件库Vasto的使用

Vasto简介

Vasto是一个分布式高性能键值存储系统，具有以下特性：

  • 基于磁盘存储
  • 最终一致性
  • 高可用性
  • 支持在不中断服务的情况下扩展或收缩

Vasto将嵌入式RocksDB扩展为分布式键值存储，增加了分片、复制和支持以下操作：

  1. 创建新的键空间
  2. 删除现有键空间
  3. 扩展键空间
  4. 收缩键空间
  5. 替换键空间中的节点

架构概述

Vasto系统由以下组件组成：

  1. 一个Vasto主节点
  2. 多个Vasto存储节点
  3. Vasto客户端或Vasto代理/网关
  • Vasto存储节点基本上是对RocksDB的简单封装
  • Vasto主节点管理所有Vasto存储节点和Vasto客户端
  • Vasto客户端依赖主节点连接到正确的Vasto存储节点
  • Vasto网关使用Vasto客户端库支持不同的API

使用示例

下面是一个完整的Vasto使用示例代码：

package main

import (
	"context"
	"github.com/chrislusf/vasto/goclient/vs"
)

func main() {
	// 创建一个Vasto客户端，连接到主节点localhost:8278
	vc := vs.NewVastoClient(context.Background(), "client_name", "localhost:8278")
	
	// 为键空间ks1创建一个集群，包含1个服务器和1份数据副本
	err := vc.CreateCluster("ks1", 1, 1)
	if err != nil {
		panic(err)
	}
	
	// 获取ks1的集群客户端
	cc := vc.NewClusterClient("ks1")

	// 使用集群客户端进行操作
	var key, value []byte
	key = []byte("my_key")
	value = []byte("my_value")
	
	// 写入数据
	err = cc.Put(key, value)
	if err != nil {
		panic(err)
	}
	
	// 读取数据
	readValue, err := cc.Get(vs.Key(key))
	if err != nil {
		panic(err)
	}
	
	// 打印读取的值
	println(string(readValue))

	// 将集群大小调整为3个服务器
	err = vc.ResizeCluster("ks1", 3)
	if err != nil {
		panic(err)
	}

	// 使用现有的集群客户端继续操作
	err = cc.Put(key, value)
	if err != nil {
		panic(err)
	}
	
	readValue, err = cc.Get(vs.Key(key))
	if err != nil {
		panic(err)
	}
	
	println(string(readValue))
}

主要API说明

  1. NewVastoClient(ctx context.Context, clientName string, masterAddress string) *VastoClient - 创建新的Vasto客户端
  2. CreateCluster(keyspace string, shardCount int, replicaCount int) error - 创建新的键空间集群
  3. NewClusterClient(keyspace string) *ClusterClient - 获取指定键空间的集群客户端
  4. Put(key []byte, value []byte) error - 写入键值对
  5. Get(key vs.Key) ([]byte, error) - 读取键对应的值
  6. ResizeCluster(keyspace string, shardCount int) error - 调整集群大小

注意事项

  1. Vasto使用Jumping Consistent Hash算法分配数据，具有以下优点：

    • 不需要存储状态
    • 数据均匀分布到桶中
    • 桶数量变化时也能均匀分配工作负载

  2. Vasto采用最终一致性和主动-主动复制策略：

    • 所有Vasto存储节点都可以读写
    • 变更会在几毫秒内传播到其他副本
    • 只有主副本参与正常操作
    • 当主副本不可用时，副本会参与操作

  3. 目前只提供了基本的Go库，网关功能尚未完成


更多关于golang分布式高性能键值存储插件库Vasto的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang分布式高性能键值存储插件库Vasto的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Vasto - Golang分布式高性能键值存储插件库

Vasto是一个用Go语言编写的分布式高性能键值存储系统，它设计用于需要低延迟和高吞吐量的场景。下面我将介绍Vasto的主要特性、架构和使用方法。

Vasto主要特性

  1. 分布式架构：支持多节点集群部署
  2. 高性能：基于内存存储，支持持久化
  3. 插件化设计：可以轻松扩展存储引擎和网络协议
  4. 一致性哈希：实现数据的均匀分布
  5. 自动故障转移：节点故障时自动恢复

基本架构

Vasto采用主从架构，包含以下组件：

  • Master节点：负责集群管理和元数据存储
  • Slave节点：实际存储数据的节点
  • 客户端库：提供API与集群交互

安装Vasto

go get github.com/vastoio/vasto

基本使用示例

1. 连接到Vasto集群

package main

import (
	"context"
	"fmt"
	"github.com/vastoio/vasto/goclient"
)

func main() {
	// 创建客户端配置
	config := goclient.NewClusterConfig(
		[]string{"127.0.0.1:8484"}, // master节点地址
	)

	// 创建客户端
	client, err := goclient.New(context.Background(), config)
	if err != nil {
		panic(err)
	}
	defer client.Close()

	// 选择要操作的bucket(类似命名空间)
	bucket := client.Bucket("my_bucket")
}

2. 基本键值操作

// 设置键值
err := bucket.Put(context.Background(), "key1", []byte("value1"))
if err != nil {
	fmt.Printf("Put error: %v\n", err)
}

// 获取值
value, err := bucket.Get(context.Background(), "key1")
if err != nil {
	fmt.Printf("Get error: %v\n", err)
} else {
	fmt.Printf("Got value: %s\n", string(value))
}

// 删除键
err = bucket.Delete(context.Background(), "key1")
if err != nil {
	fmt.Printf("Delete error: %v\n", err)
}

3. 批量操作

// 批量写入
batch := bucket.NewBatch()
batch.Put("key2", []byte("value2"))
batch.Put("key3", []byte("value3"))
err := batch.Execute(context.Background())
if err != nil {
	fmt.Printf("Batch error: %v\n", err)
}

// 批量读取
keys := []string{"key2", "key3"}
values, err := bucket.MultiGet(context.Background(), keys)
if err != nil {
	fmt.Printf("MultiGet error: %v\n", err)
} else {
	for i, v := range values {
		fmt.Printf("Key: %s, Value: %s\n", keys[i], string(v))
	}
}

4. 高级特性

过期时间设置

// 设置键值，10秒后过期
err := bucket.PutWithTTL(context.Background(), "temp_key", []byte("temp_value"), 10)
if err != nil {
	fmt.Printf("PutWithTTL error: %v\n", err)
}

原子计数器

// 初始化计数器
bucket.Put(context.Background(), "counter", []byte("0"))

// 原子递增
newVal, err := bucket.Increment(context.Background(), "counter", 1)
if err != nil {
	fmt.Printf("Increment error: %v\n", err)
} else {
	fmt.Printf("New counter value: %d\n", newVal)
}

性能优化建议

  1. 使用连接池：客户端会自动维护连接池，但可以配置大小
  2. 批量操作：尽可能使用批量操作减少网络往返
  3. 合理设置TTL：避免不必要的数据积累
  4. 监控集群状态：定期检查节点健康状况

集群管理示例

// 创建集群配置
clusterConfig := &goclient.ClusterConfig{
	MasterNodes:    []string{"127.0.0.1:8484", "127.0.0.1:8485"},
	ConnectTimeout: 5 * time.Second,
	ReadTimeout:    3 * time.Second,
	WriteTimeout:   3 * time.Second,
	MaxConnections: 100,
}

// 创建有更多配置选项的客户端
client, err := goclient.NewWithConfig(context.Background(), clusterConfig)
if err != nil {
	panic(err)
}
defer client.Close()

错误处理

Vasto操作可能会返回以下常见错误：

  • ErrKeyNotFound: 键不存在
  • ErrClusterUnavailable: 集群不可用
  • ErrTimeout: 操作超时
value, err := bucket.Get(context.Background(), "nonexistent_key")
if err == goclient.ErrKeyNotFound {
	fmt.Println("Key not found")
} else if err != nil {
	fmt.Printf("Error: %v\n", err)
}

Vasto是一个功能强大且灵活的键值存储系统，特别适合需要高性能和可扩展性的场景。通过其插件化设计，可以轻松扩展以满足特定需求。

回到顶部