Valkey 深度拆解：当 Linux 基金会决定「干掉 Redis 的许可证枷锁」——一个 25K Star 的开源分支如何用异步 I/O 重写和 RDMA 支持重新定义内存数据库的性能天花板

引言：一场许可证风暴引发的开源革命

2024 年 3 月，Redis Labs 将 Redis 的许可证从宽松的 BSD-3-Clause 变更为双重限制性许可（RSALv2 + SSPLv1）。这一变动在开源社区引发剧烈震荡——RSALv2 禁止将 Redis 作为托管服务提供给第三方，直接冲击云厂商；SSPLv1 要求提供"程序即服务"时公开整个服务端代码。对于依赖 Redis 的企业和云服务商而言，这意味着法律风险和供应商锁定的双重威胁。

仅仅一个月后，Linux 基金会联合 AWS、Google、Oracle、Snap、Ericsson 等巨头，从 Redis 7.2.4（最后一个 BSD 版本）分叉出 Valkey。其核心使命："保留一个社区所有、采用宽松 Apache/BSD 许可的真正开源替代方案，杜绝任何单一厂商单方面改变规则的可能。"

短短两年，Valkey GitHub Stars 突破 25.4k，Fork 数达 1.1k，社区增速惊人。2025 年底调查显示，42% 的用户已迁移或计划迁移到 Valkey。Spring Data Valkey 在 2026 年 4 月正式发布，标志着 Valkey 在 Java 生态中获得"一等公民"地位。

这不是一次简单的代码分叉，而是一次架构层面的全面进化。本文将从架构设计、性能优化、集群扩展、RDMA 网络层、AI 场景支撑等多个维度，深度拆解 Valkey 如何在兼容 Redis 的同时实现了质的飞跃。

一、架构剖析：在兼容中超越

1.1 核心架构继承与突破

Valkey 完全继承 Redis 的单线程事件循环模型，确保命令执行的原子性和无锁优势。但在此基础上进行了三项关键架构升级。

异步 I/O 线程重写

Redis 6.0 引入的多线程 I/O 存在性能瓶颈，Valkey 8.0 彻底重写了这一层：

• 核心改动：将 epoll_wait 等昂贵的套接字轮询操作从主线程卸载到独立 I/O 工作线程
• 关键约束：命令执行仍保持单线程，避免多线程带来的锁竞争和原子性破坏
• 智能调度：根据实时负载动态分配 I/O 任务到多核

性能数据（AWS c7g.4xlarge，16 vCPU）：

在 AWS c8g.2xlarge（Graviton4，8 vCPU）的对比测试中，Valkey 8.1 的 GET/SET 性能均显著优于 Redis 8.0。

I/O 线程的工作原理可以用以下伪代码理解：

// Valkey I/O 线程调度模型（简化）
void io_thread_main(void *arg) {
    io_thread *thread = (io_thread *)arg;
    while (1) {
        // 从主线程获取待处理的客户端列表
        client **clients = get_pending_clients(thread->id);
        int count = get_pending_count(thread->id);
        
        for (int i = 0; i < count; i++) {
            client *c = clients[i];
            // 执行网络 I/O：读取请求 / 写入响应
            if (c->flags & CLIENT_PENDING_READ) {
                readQueryFromClient(c->conn);
            } else if (c->flags & CLIENT_PENDING_WRITE) {
                writeToClient(c, 0);
            }
        }
        
        // 通知主线程 I/O 完成
        signal_io_complete(thread->id);
    }
}

关键设计要点：

1. 读写分离：读操作和写操作可以并行处理，但同一客户端的读写不会并发
2. 内存分配卸载：对象释放操作从主线程卸载到 I/O 线程，减少主线程停顿
3. 动态线程数：可通过 io-threads 配置动态调整，建议等于 CPU 核数

CPU 缓存友好的字典结构

Valkey 8.0 重新实现了核心哈希表，将键直接嵌入字典条目，每个键减少 8 字节开销，整体内存效率提升约 20%。这对于海量小 key 场景（如会话存储、设备状态）意义重大。

// Redis 旧字典条目（简化）
typedef struct dictEntry {
    void *key;           // 8 字节指针
    void *val;           // 8 字节指针
    struct dictEntry *next;  // 8 字节链表指针
} dictEntry;             // 共 24 字节

// Valkey 新字典条目（简化）
typedef struct dictEntry {
    union {
        void *val;       // 8 字节
        uint64_t u64;    // 8 字节（小整数优化）
        int64_t s64;     // 8 字节
        double d;        // 8 字节
    } v;
    struct dictEntry *next;  // 8 字节
    // key 直接嵌入，省去指针开销
    unsigned char key[];     // 柔性数组，0 字节指针开销
} dictEntry;             // 共 16 字节 + key 实际大小

当存储 100 万个短 key（平均 16 字节）时，仅字典结构就能节省约 8MB 内存。在大规模缓存场景下，这个优化的效果非常显著。

双通道复制（Dual Channel Replication）

Valkey 8.0 引入了双通道复制机制：

• 全量同步期间同时流式传输 RDB 快照和复制积压日志
• 使用独立连接进行 RDB 传输，释放主进程处理客户端查询
• 大幅缩短主从切换时的窗口期

# 双通道复制配置
replica-serve-stale-data yes
repl-diskless-sync yes
repl-diskless-sync-delay 5
repl-diskless-load on-empty-db

1.2 实验性 RDMA 支持：网络层的降维打击

Valkey 在 2024 年 7 月开始实验性支持 RDMA（远程直接内存访问）作为传输层，这是 Redis 目前尚未提供的原生能力。

技术原理：

• 绕过内核网络栈，直接内存到内存传输
• 零拷贝（Zero Copy）减少 CPU 参与
• 适合低延迟、高吞吐的 HPC/AI 场景

性能表现（1KB KV 场景）：

在 Intel Xeon Platinum + Mellanox ConnectX-5 环境下，单核 QPS 已突破 450K。2025 年 5 月，libvalkey 0.1.0 正式发布，原生集成 RDMA 支持，valkey-cli 和 valkey-benchmark 均已支持 --rdma 参数。

# 使用 RDMA 进行性能测试
valkey-benchmark -h valkey-server -p 6379 -n 1000000 -c 50 --rdma

# RDMA 连接配置
valkey-cli --rdma -h valkey-server -p 6379

RDMA 的引入使得 Valkey 在以下场景中具有独特优势：

1. AI 推理服务：特征存储需要微秒级延迟，RDMA 可以将网络延迟从百微秒级降到个位数微秒
2. 高频交易：金融场景对延迟极度敏感，RDMA 的零拷贝特性可以显著降低尾延迟
3. 大规模集群通信：节点间 Gossip 通信和数据迁移可以利用 RDMA 加速

二、集群与高可用：生产级部署实践

2.1 原生架构概览

Valkey 完整兼容 Redis 的三种部署模式：

2.2 哨兵模式高可用部署

Valkey 的哨兵机制与 Redis 完全兼容，但 Valkey 9.0 引入了 Coordinated Failover 改进，优化 SENTINEL FAILOVER 命令的协调机制。

生产配置模板：

# sentinel.conf
port 26379
daemonize yes
dir "/var/lib/valkey/sentinel"

# 监控主节点，2 个哨兵同意才判定客观下线
sentinel monitor mymaster 192.168.1.10 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 10000

# 密码认证（如有）
sentinel auth-pass mymaster your_password

# 防止故障转移后旧主节点自动重启导致脑裂
sentinel deny-scripts-reconfig yes

Docker Compose 快速部署：

version: '3.8'
services:
  valkey-master:
    image: valkey/valkey:8-alpine
    command: valkey-server --appendonly yes --requirepass secret
    ports:
      - "6379:6379"
    volumes:
      - valkey-data:/data

  valkey-replica:
    image: valkey/valkey:8-alpine
    command: valkey-server --replicaof valkey-master 6379 --masterauth secret
    depends_on:
      - valkey-master

  sentinel-1:
    image: valkey/valkey:8-alpine
    command: valkey-sentinel /etc/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/sentinel.conf

  sentinel-2:
    image: valkey/valkey:8-alpine
    command: valkey-sentinel /etc/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/sentinel.conf

  sentinel-3:
    image: valkey/valkey:8-alpine
    command: valkey-sentinel /etc/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/sentinel.conf

volumes:
  valkey-data:

2.3 Cluster 集群模式：2000 节点的极限扩展

Valkey 9.0 在集群规模上实现了突破，测试配置支持 2000 节点（1000 主 + 1000 副本），达到 10 亿 RPS 的聚合吞吐量。

关键优化：

• 多主节点故障处理：引入排名机制防止投票冲突，50% 主节点故障时仍能自动恢复
• 连接节流：防止大规模故障时的重连风暴
• Gossip 优化：Radix Tree 按秒分组故障报告，减少冗余处理
• 轻量化 Pub/Sub：头部从 ~2KB 降至 ~30 字节

集群创建命令：

# 启动 6 个节点（3 主 3 从）
for port in 6379 6380 6381 6382 6383 6384; do
  valkey-server --port $port --cluster-enabled yes \
    --cluster-config-file nodes-$port.conf \
    --appendonly yes --daemonize yes
done

# 组建集群
valkey-cli --cluster create \
  127.0.0.1:6379 127.0.0.1:6380 127.0.0.1:6381 \
  127.0.0.1:6382 127.0.0.1:6383 127.0.0.1:6384 \
  --cluster-replicas 1

2.4 多可用区部署：云原生容灾

Valkey 8.1 引入 availability-zone 配置，支持客户端就近接入：

# valkey.conf
availability-zone "cn-north-1a"

部署准则：

• 主节点与副本必须跨可用区
• 仲裁节点（Arbiter）至少 3 个，分布于不同 AZ
• 客户端优先连接同 AZ 节点，降低延迟和跨区流量成本

# Python 客户端：同可用区优先读取
from valkey import Valkey
from valkey.cluster import ValkeyCluster

cluster = ValkeyCluster(
    startup_nodes=[
        {"host": "valkey-az1.example.com", "port": "6379"},
        {"host": "valkey-az2.example.com", "port": "6379"},
        {"host": "valkey-az3.example.com", "port": "6379"},
    ],
    read_from_replicas=True,  # 读走副本，降低主节点压力
    skip_full_coverage_check=True
)

三、代码集成：Java 与 Python 实战

3.1 Java 集成：Spring Data Valkey

2026 年 4 月，Spring Data Valkey 正式发布，标志着 Valkey 在 Java 生态中获得"一等公民"地位，不再需要伪装成 Redis 连接。

Maven 依赖：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-valkey</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>io.valkey</groupId>
    <artifactId>valkey-java-client</artifactId>
    <version>5.0.0</version>
</dependency>

配置类（集群模式）：

@Configuration
public class ValkeyConfig {

    @Bean
    public ValkeyConnectionFactory valkeyConnectionFactory() {
        // 集群配置
        ValkeyClusterConfiguration clusterConfig = new ValkeyClusterConfiguration(
            Arrays.asList("node1:6379", "node2:6379", "node3:6379")
        );
        clusterConfig.setMaxRedirects(3);

        // 客户端配置：优先读副本，支持同可用区路由
        ClientConfiguration clientConfig = ValkeyClientConfiguration.builder()
            .readFrom(ReadFrom.REPLICA_PREFERRED)
            .build();

        return new LettuceValkeyConnectionFactory(clusterConfig, clientConfig);
    }

    @Bean
    public ValkeyTemplate<String, Object> valkeyTemplate(
            ValkeyConnectionFactory factory) {
        ValkeyTemplate<String, Object> template = new ValkeyTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

业务层使用：

@Service
public class CacheService {
    @Autowired
    private StringValkeyTemplate valkeyTemplate;

    // 缓存 + TTL
    public void cacheUser(String userId, User user) {
        valkeyTemplate.opsForValue().set(
            "user:" + userId,
            user,
            Duration.ofMinutes(30)
        );
    }

    // 分布式锁（Lua 保证原子性）
    public boolean tryLock(String lockKey, String requestId, int expireSeconds) {
        String lua = "if valkey.call('setnx', KEYS[1], ARGV[1]) == 1 then " +
            "return valkey.call('expire', KEYS[1], ARGV[2]) " +
            "else return 0 end";
        Long result = valkeyTemplate.execute(
            new DefaultValkeyScript<>(lua, Long.class),
            Collections.singletonList(lockKey),
            requestId, String.valueOf(expireSeconds)
        );
        return result != null && result == 1;
    }

    // 排行榜（Sorted Set）
    public List<TypedTuple<String>> getTop10(String board) {
        return valkeyTemplate.opsForZSet()
            .reverseRangeWithScores(board, 0, 9);
    }
}

3.2 Python 集成：valkey-py

Valkey 官方提供 valkey-py 客户端，完全兼容 redis-py 的 API，同时针对 Valkey 特性优化。

安装：

pip install valkey[hiredis]  # hiredis 加速协议解析

连接池与集群：

from valkey import Valkey
from valkey.cluster import ValkeyCluster
from valkey.sentinel import Sentinel
import json

# 单机/主从模式
client = Valkey(
    host='localhost',
    port=6379,
    db=0,
    decode_responses=True,
    max_connections=50,
    socket_keepalive=True
)

# 哨兵模式（高可用）
sentinel = Sentinel([
    ('sentinel1', 26379),
    ('sentinel2', 26379),
    ('sentinel3', 26379)
])
master = sentinel.master_for('mymaster', socket_timeout=0.5)

# 集群模式
startup_nodes = [
    {"host": "192.168.1.10", "port": "6379"},
    {"host": "192.168.1.11", "port": "6379"},
    {"host": "192.168.1.12", "port": "6379"}
]
cluster = ValkeyCluster(
    startup_nodes=startup_nodes,
    decode_responses=True,
    skip_full_coverage_check=True,
    max_connections_per_node=20,
    read_from_replicas=True  # 读走副本
)

# 常用操作
def cache_with_ttl(key: str, data: dict, ttl: int = 3600):
    cluster.hset(f"cache:{key}", mapping=data)
    cluster.expire(f"cache:{key}", ttl)

def rate_limit(user_id: str, max_requests: int = 100, window: int = 60):
    key = f"rate:{user_id}"
    pipe = cluster.pipeline()
    pipe.incr(key)
    pipe.expire(key, window)
    current, _ = pipe.execute()
    return current <= max_requests

# Stream 消息队列（消费组模式）
def consume_events(stream: str, group: str, consumer: str):
    messages = cluster.xreadgroup(
        group, consumer,
        {stream: '>'},  # 读取新消息
        count=10,
        block=5000  # 阻塞 5 秒
    )
    for stream_name, msgs in messages:
        for msg_id, fields in msgs:
            process_event(fields)
        cluster.xack(stream, group, msg_id)  # 确认消费

四、Valkey-Search：向量搜索与 AI 支撑

4.1 架构定位

Valkey 官方推出 Valkey-Search 模块（BSD 许可），作为 Redis Search 的兼容替代，专注于向量搜索场景：

[文本/图像] → [Embedding 模型] → [Valkey-Search 向量索引] → [KNN/ANN 查询] → [Top-K 结果]

核心特性：

• HNSW ANN 算法：时间复杂度 O(log N)，支持 L2、内积、余弦相似度
• 混合查询：向量相似度 + 数值/标签过滤（AND/OR/NOT）
• 多线程查询：CPU 核数线性提升查询吞吐
• RDB 快照集成：索引定义和向量数据随快照持久化，避免重建

4.2 实战：语义搜索

# 创建向量索引（768 维，余弦相似度）
FT.CREATE doc_idx ON HASH PREFIX 1 doc:
  SCHEMA title TEXT
  content VECTOR HNSW 6 DIM 768 DISTANCE_METRIC COSINE
  category TAG

# 添加文档（向量由外部模型生成）
HSET doc:1 title "Valkey 入门" content <768-dim-vector> category "database"

# 向量搜索（找最相似的 5 条）
FT.SEARCH doc_idx "*=>[KNN 5 @content $vec]"
  PARAMS 2 vec <query-vector>
  RETURN 3 title category score

4.3 AI 场景支撑矩阵

# 语义缓存示例
import hashlib
from valkey import Valkey

client = Valkey(host='localhost', port=6379, decode_responses=True)

def semantic_cache(query: str, embedding_fn, ttl: int = 3600):
    """带语义缓存的 LLM 查询"""
    # 生成查询向量
    query_vec = embedding_fn(query)
    
    # 在 Valkey-Search 中查找相似缓存
    results = client.execute_command(
        'FT.SEARCH', 'llm_cache',
        f'*=>[KNN 1 @embedding $vec]',
        'PARAMS', '2', 'vec', query_vec.tobytes(),
        'RETURN', '2', 'response', 'score'
    )
    
    if results and results[1] > 0.95:  # 相似度阈值
        return results[2]['response']  # 缓存命中
    
    # 缓存未命中，调用 LLM
    response = call_llm(query)
    
    # 写入缓存
    cache_key = hashlib.md5(query.encode()).hexdigest()
    client.hset(f'llm:{cache_key}', mapping={
        'query': query,
        'response': response,
        'embedding': query_vec.tobytes()
    })
    client.expire(f'llm:{cache_key}', ttl)
    
    return response

五、性能优化：从配置到内核的全栈调优

5.1 编译优化

# 克隆源码
git clone https://github.com/valkey-io/valkey.git
cd valkey

# 高性能编译（生产推荐）
make BUILD_TLS=yes \
     BUILD_RDMA=module \
     CFLAGS="-DUSE_PROCESSOR_CLOCK -O3" \
     MALLOC=jemalloc

# 安装并创建兼容符号链接
make install
# 自动生成 redis-server → valkey-server 等软链接，平滑迁移

5.2 关键配置调优

# valkey.conf 生产模板

# === 网络与 I/O ===
port 6379
io-threads 8                    # 启用多线程 I/O，建议等于 CPU 核数
io-threads-do-reads yes         # 读操作也走 I/O 线程
tcp-keepalive 60

# === 内存管理 ===
maxmemory 8gb
maxmemory-policy allkeys-lru    # 全量键 LRU 淘汰
maxmemory-samples 10
activedefrag yes                # 自动碎片整理

# === 持久化 ===
appendonly yes
appendfsync everysec            # 每秒刷盘，平衡性能与安全
no-appendfsync-on-rewrite yes   # 重写时暂停 AOF 同步

save 900 1                      # RDB：15 分钟至少 1 次变更则快照
save 300 10
save 60 10000

# === 集群 ===
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-require-full-coverage no

# === 慢查询监控 ===
slowlog-log-slower-than 10000   # 10ms 阈值
slowlog-max-len 128

# === 多可用区（云环境）===
availability-zone "cn-north-1a"

5.3 监控指标清单

# 监控脚本示例
from valkey import Valkey
import time

client = Valkey(host='localhost', port=6379, decode_responses=True)

def check_health():
    info = client.info()
    
    alerts = []
    
    # 内存检查
    used_pct = info['used_memory'] / info['maxmemory'] * 100
    if used_pct > 85:
        alerts.append(f"内存使用率 {used_pct:.1f}% 超过 85%")
    
    # 连接数检查
    clients = info['connected_clients']
    max_clients = info['maxclients']
    if clients > max_clients * 0.8:
        alerts.append(f"连接数 {clients}/{max_clients} 超过 80%")
    
    # 复制延迟
    if 'master_repl_offset' in info:
        offset_diff = info.get('slave0', {}).get('offset', 0)
        if offset_diff > 1000000:  # 1MB 延迟
            alerts.append(f"主从复制延迟 {offset_diff} bytes")
    
    return alerts

while True:
    alerts = check_health()
    if alerts:
        print(f"[ALERT] {time.strftime('%Y-%m-%d %H:%M:%S')}")
        for alert in alerts:
            print(f"  - {alert}")
    time.sleep(60)

六、Redis 迁移实战：零停机切换指南

6.1 迁移兼容性

Valkey 100% 兼容 Redis 7.2.4 协议，迁移过程对客户端透明：

# 1. 安装 Valkey（自动创建兼容符号链接）
make install
# /usr/local/bin/valkey-server
# /usr/local/bin/valkey-cli
# /usr/local/bin/redis-server → valkey-server（兼容链接）
# /usr/local/bin/redis-cli → valkey-cli（兼容链接）

# 2. 停止 Redis，启动 Valkey（使用相同配置文件）
redis-cli shutdown
valkey-server /etc/redis/redis.conf  # 配置文件完全兼容

# 3. 验证数据完整性
valkey-cli dbsize
valkey-cli info keyspace

6.2 从 Redis 7.x 到 Valkey 8.x 的配置变更

大部分配置项完全兼容，以下是需要注意的新增配置：

# 新增：I/O 线程配置
io-threads 8
io-threads-do-reads yes

# 新增：可用区配置
availability-zone "cn-north-1a"

# 新增：RDMA 配置（实验性）
rdma-port 6380

# 变更：集群配置文件格式（向后兼容）
cluster-config-file nodes.conf

6.3 回滚方案

如果迁移后出现问题，可以快速回滚到 Redis：

# 1. 停止 Valkey
valkey-cli shutdown

# 2. 启动 Redis（数据文件完全兼容）
redis-server /etc/redis/redis.conf

# 3. 验证
redis-cli ping

七、与竞品的差异化对比

7.1 Valkey vs Redis vs Dragonfly vs Garnet

7.2 选型决策树

开始
 │
 ├─ 许可证敏感？（金融/上市公司/云厂商）
 │  └─ 是 → Valkey（BSD 零风险）
 │  └─ 否 → 继续评估
 │
 ├─ 需要 Redis Stack 高级功能？（TimeSeries/JSON 原生集成/语义缓存）
 │  └─ 是 → Redis 8.x（功能更全）
 │  └─ 否 → 继续评估
 │
 ├─ 追求极致性能/大规模集群？
 │  └─ 是 → Dragonfly（10M+ RPS）或 Garnet（3M+ RPS）
 │  └─ 否 → 继续评估
 │
 ├─ 需要 RDMA/HPC 场景？
 │  └─ 是 → Valkey（唯一选择）
 │  └─ 否 → 继续评估
 │
 └─ .NET 生态？
    └─ 是 → Garnet（MIT 许可，.NET 原生）
    └─ 否 → Valkey（社区最活跃，云厂商背书）

八、AI+ 时代的展望

8.1 当前定位：AI 基础设施的"热数据层"

Valkey 在 AI 时代的角色正在从"缓存"进化为**"实时智能数据层"**：

• 特征存储：毫秒级读写用户实时行为特征，支撑在线推理
• 向量检索：Valkey-Search 提供低延迟语义搜索，替代专用向量数据库（如 Milvus）在简单场景的地位
• 语义缓存：缓存 LLM 查询结果，降低推理成本
• 流式处理：Stream 数据结构支撑实时事件管道，对接 ML 特征工程

8.2 路线图与长期愿景

根据 Valkey 社区规划：

Valkey 的长期战略是与 Redis 差异化发展：Redis 专注企业级 AI 功能（语义缓存、混合搜索），Valkey 专注核心性能、开源合规、大规模集群扩展，并向更持久化、更一致性的通用数据库演进。

九、总结：为什么 Valkey 是最佳选择

Valkey 的崛起证明了一个开源真理：当守护者变成掠夺者，社区会创造新的守护者。

最终建议：

• 如果你的应用当前使用 Redis 7.2 及以下版本，或对新项目的许可证合规性有顾虑，Valkey 是毫无争议的最佳选择。迁移成本趋近于零，性能收益立竿见影，法律风险彻底消除。
• 如果你深度依赖 Redis Stack 的 TimeSeries、原生 JSON 语义缓存、FT.HYBRID 混合搜索等高级功能，且能接受 AGPLv3 的 copyleft 义务，可继续评估 Redis 8.x。
• 如果你需要极致性能（10M+ RPS），可以考虑 Dragonfly，但需注意其 BSL 1.1 许可证的商业限制。

在 AI 时代，选择一个由社区共同拥有、性能持续突破、许可证永不变更的数据基础设施，是对技术栈长期安全最负责任的投资。

参考资料：

• Valkey GitHub：https://github.com/valkey-io/valkey
• Valkey 官方文档：https://valkey.io
• Valkey 8.0 Release Notes：https://github.com/valkey-io/valkey/releases
• AWS ElastiCache for Valkey：https://aws.amazon.com/elasticache/valkey/
• Spring Data Valkey：https://spring.io/projects/spring-data-valkey