KVCacheStore:Quick start

Console

1. Log on to the KVCacheStore console. You can switch regions at the top of the page.

2. Click Create KVCacheStore and configure the resource.

3. Click Create Now and follow the on-screen instructions to place the order.

API

Call the CreateKVCacheStore operation to create a pay-as-you-go KVCacheStore. Sample request:

POST /?Action=CreateKVCacheStore&Version=2026-06-17 HTTP/1.1
Host: kvcachestore.cn-wulanchabu.aliyuncs.com
Content-Type: application/x-www-form-urlencoded

RegionId=cn-wulanchabu
&ZoneId=cn-wulanchabu-a
&HpnZone=A1
&Capacity=307200
&Name=my-kvcachestore
&ChargeType=POSTPAY
&ClientToken=0d796d82-9fcf-4616-84be-92758f70ed54

Sample success response:

{
  "RequestId": "019F6A7C-DFBB-16BA-BCD3-5C6F6B16D67B",
  "KvcsId": "kvcs-cn-xxxxxxxxxxxx",
  "OrderId": "299101502720755"
}

This operation is asynchronous. After the operation returns the KVCacheStore ID, wait until the KVCacheStore enters the Available state before you attach it.

Python

from kvcs import KvcsLowLevelClient, LLPutItem, LLGetItemOpt

client = KvcsLowLevelClient(efc_socket="/var/run/kvcs/efc-grpc.sock")

put_results = client.ll_batch_put(
    [LLPutItem(key="k1", value=b"v1")],
    deadline_s=10.0,
)
print("ll_batch_put status:", put_results[0].status)

# Copy-out: The SDK allocates memory and returns the data.
get_results = client.ll_batch_get_items(
    [LLGetItemOpt(key="k1")],
    deadline_s=10.0,
)
assert get_results[0].data == b"v1"
print("ll_batch_get_items data:", get_results[0].data)

# Copy-into: Data is written directly to a caller-provided buffer.
buf = bytearray(1024)
get_into_results = client.ll_batch_get_into_items(
    [LLGetItemOpt(key="k1")],
    [buf],
    deadline_s=10.0,
)
actual_len = get_into_results[0].data_len
assert buf[:actual_len] == b"v1"
print("ll_batch_get_into_items data:", bytes(buf[:actual_len]))

query_results = client.ll_batch_query(["k1"])
print("ll_batch_query status:", query_results[0].status)

delete_results = client.ll_batch_delete(["k1"], deadline_s=10.0)
print("ll_batch_delete status:", delete_results[0])
client.close()

Go

package main

import (
    "context"
    "fmt"
    "time"

    kvcs "github.com/alibaba/kvcachestore-sdk/go"
)

func main() {
    client, err := kvcs.NewKvcsLowLevelClient(kvcs.KvcsLowLevelConfig{
        EFCSocket: "/var/run/kvcs/efc-grpc.sock",
    })
    if err != nil {
        panic(err)
    }
    defer client.Close()

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    putResults, err := client.LLBatchPut(ctx, []kvcs.LLPutItem{
        {Key: "k1", Value: [][]byte{[]byte("v1")}},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("LLBatchPut status:", putResults[0].Status)

    // Copy-out: The SDK allocates memory and returns the data.
    getResults, err := client.LLBatchGetItems(ctx, []kvcs.LLGetItemOpt{
        {Key: "k1"},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("LLBatchGetItems data:", string(getResults[0].Data))

    // Copy-into: Data is written directly to a caller-provided buffer.
    buf := make([]byte, 1024)
    getIntoResults, err := client.LLBatchGetIntoItems(ctx,
        []kvcs.LLGetItemOpt{{Key: "k1"}},
        [][]byte{buf},
    )
    if err != nil {
        panic(err)
    }
    actualLen := getIntoResults[0].DataLen
    fmt.Println("LLBatchGetIntoItems data:", string(buf[:actualLen]))

    queryResults, err := client.LLBatchQuery(ctx, []string{"k1"})
    if err != nil {
        panic(err)
    }
    fmt.Println("LLBatchQuery status:", queryResults[0].Status)

    deleteResults, err := client.LLBatchDelete(ctx, []string{"k1"})
    if err != nil {
        panic(err)
    }
    fmt.Println("LLBatchDelete status:", deleteResults[0])
}

Rust

use kvcs::*;
use std::time::Duration;

fn main() {
    let client = KvcsLowLevelClient::new(KvcsLowLevelConfig {
        efc_socket: "/var/run/kvcs/efc-grpc.sock".into(),
        ..Default::default()
    }).unwrap();
    let deadline = Some(Duration::from_secs(10));
    let opts = LLBatchOptions::default();

    let put_results = client.ll_batch_put(&[LLPutItem {
        key: "k1",
        value: &[b"v1"],
    }], deadline, opts).unwrap();
    println!("ll_batch_put status: {}", put_results[0].status);

    // Copy-out: The SDK allocates memory and returns the data.
    let get_results = client.ll_batch_get_items(
        &[LLGetItemOpt { key: "k1" }],
        deadline,
        opts,
    ).unwrap();
    assert_eq!(get_results[0].data.as_deref(), Some(b"v1".as_slice()));
    println!("ll_batch_get_items data: {:?}", get_results[0].data);

    // Copy-into: Data is written directly to a caller-provided buffer.
    let mut buf = vec![0u8; 1024];
    let get_into_results = client.ll_batch_get_into_items(
        &[LLGetItemOpt { key: "k1" }],
        &mut [&mut buf[..]],
        deadline,
        opts,
    ).unwrap();
    let actual_len = get_into_results[0].data_len;
    assert_eq!(&buf[..actual_len], b"v1");
    println!("ll_batch_get_into_items data: {:?}", &buf[..actual_len]);

    let query_results = client.ll_batch_query(&["k1"], opts).unwrap();
    println!("ll_batch_query status: {}", query_results[0].status);

    let delete_results = client.ll_batch_delete(&["k1"], deadline, opts).unwrap();
    println!("ll_batch_delete status: {}", delete_results[0]);
}