Momento Cache API リファレンス
コントロールAPI
これらのAPIメソッドは、cacheを管理・制御するために使用されます。
Create cache
指定された名前のcacheを作成します。
属性:
名前 | 型 | 説明 |
---|---|---|
cacheName | String | 作成するcacheの名前。 |
- JavaScript
- Python
- Java
- Go
- C#
- PHP
- Elixir
const result = await cacheClient.createCache('test-cache');
if (result instanceof CreateCache.Success) {
console.log("Cache 'test-cache' created");
} else if (result instanceof CreateCache.AlreadyExists) {
console.log("Cache 'test-cache' already exists");
} else if (result instanceof CreateCache.Error) {
throw new Error(
`An error occurred while attempting to create cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
create_cache_response = await cache_client.create_cache('test-cache')
match create_cache_response:
case CreateCache.Success():
print("Cache 'test-cache' created")
case CreateCache.CacheAlreadyExists():
print("Cache 'test-cache' already exists.")
case CreateCache.Error() as error:
print(f"An error occurred while attempting to create cache 'test-cache': {error.message}")
final CacheCreateResponse response = cacheClient.createCache("test-cache").join();
if (response instanceof CacheCreateResponse.Success) {
System.out.println("Cache 'test-cache' created");
} else if (response instanceof CacheCreateResponse.Error error) {
if (error.getCause() instanceof AlreadyExistsException) {
System.out.println("Cache 'test-cache' already exists");
} else {
throw new RuntimeException(
"An error occurred while attempting to create cache 'test-cache': "
+ error.getErrorCode(),
error);
}
}
_, err := client.CreateCache(ctx, &momento.CreateCacheRequest{
CacheName: "cache-name",
})
if err != nil {
panic(err)
}
var result = await cacheClient.CreateCacheAsync("test-cache");
if (result is CreateCacheResponse.Success)
{
Console.WriteLine("Cache 'test-cache' created");
}
else if (result is CreateCacheResponse.CacheAlreadyExists)
{
Console.WriteLine("Cache 'test-cache' already exists");
}
else if (result is CreateCacheResponse.Error error)
{
throw new Exception($"An error occurred while attempting to create cache 'test-cache': {error.ErrorCode}: {error}");
}
$create_cache_response = $cache_client->createCache("test-cache");
if ($create_cache_response->asSuccess()) {
print("Cache 'test-cache' created\n");
} elseif ($create_cache_response->asAlreadyExists()) {
print("Cache 'test-cache' already exists\n");
} elseif ($err = $create_cache_response->asError()) {
print("An error occurred while attempting to create 'test-cache': {$err->errorCode()} - {$err->message()}\n");
}
case Momento.CacheClient.create_cache(client, "test-cache") do
{:ok, _} ->
IO.puts("Cache 'test-cache' created")
:already_exists ->
:ok
{:error, error} ->
IO.puts(
"An error occurred while attempting to create cache 'test-cache': #{error.error_code}"
)
raise error
end
Delete cache
cacheを削除します。
属性:
名前 | 型 | 説明 |
---|---|---|
cacheName | String | 削除するcacheの名前。 |
- JavaScript
- Python
- Java
- C#
- PHP
- Elixir
const result = await cacheClient.deleteCache('test-cache');
if (result instanceof DeleteCache.Success) {
console.log("Cache 'test-cache' deleted");
} else if (result instanceof DeleteCache.Error) {
throw new Error(
`An error occurred while attempting to delete cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
delete_cache_response = await cache_client.delete_cache('test-cache')
match delete_cache_response:
case DeleteCache.Success():
print("Cache 'test-cache' deleted")
case DeleteCache.Error() as error:
raise Exception(f"An error occurred while attempting to delete 'test-cache': {error.message}")
final CacheDeleteResponse response = cacheClient.deleteCache("test-cache").join();
if (response instanceof CacheDeleteResponse.Success) {
System.out.println("Cache 'test-cache' deleted");
} else if (response instanceof CacheDeleteResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to delete cache 'test-cache': "
+ error.getErrorCode(),
error);
}
var result = await cacheClient.DeleteCacheAsync("test-cache");
if (result is DeleteCacheResponse.Success)
{
Console.WriteLine("Cache 'test-cache' deleted");
}
else if (result is DeleteCacheResponse.Error error)
{
throw new Exception($"An error occurred while attempting to delete cache 'test-cache': {error.ErrorCode}: {error}");
}
$delete_cache_response = $cache_client->deleteCache('test-cache');
if ($err = $delete_cache_response->asError()) {
print("An error occurred while attempting to delete 'test-cache': {$err->errorCode()} - {$err->message()}\n");
} else {
print("Cache 'test-cache' deleted\n");
}
case Momento.CacheClient.delete_cache(client, "test-cache") do
{:ok, _} ->
IO.puts("Cache 'test-cache' deleted")
{:error, error} ->
IO.puts(
"An error occurred while attempting to delete cache 'test-cache': #{error.error_code}"
)
raise error
end
List caches
すべてのcacheのリストを返します。
名前 | 型 | 説明 |
---|---|---|
nextToken | String | cacheのページネーション用の トークンです。 |
- JavaScript
- Python
- Java
- Go
- C#
- PHP
- Elixir
const result = await cacheClient.listCaches();
if (result instanceof ListCaches.Success) {
console.log(
`Caches:\n${result
.getCaches()
.map(c => c.getName())
.join('\n')}\n\n`
);
} else if (result instanceof ListCaches.Error) {
throw new Error(`An error occurred while attempting to list caches: ${result.errorCode()}: ${result.toString()}`);
}
print("Listing caches:")
list_caches_response = await cache_client.list_caches()
match list_caches_response:
case ListCaches.Success() as success:
for cache_info in success.caches:
print(f"- {cache_info.name!r}")
case ListCaches.Error() as error:
raise Exception(f"An error occurred while attempting to list caches: {error.message}")
final CacheListResponse response = cacheClient.listCaches().join();
if (response instanceof CacheListResponse.Success success) {
final String caches =
success.getCaches().stream().map(CacheInfo::name).collect(Collectors.joining("\n"));
System.out.println("Caches:\n" + caches);
} else if (response instanceof CacheListResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to list caches: " + error.getErrorCode(), error);
}
resp, err := client.ListCaches(ctx, &momento.ListCachesRequest{})
if err != nil {
panic(err)
}
switch r := resp.(type) {
case *responses.ListCachesSuccess:
log.Printf("Found caches %+v", r.Caches())
}
var result = await cacheClient.ListCachesAsync();
if (result is ListCachesResponse.Success success)
{
Console.WriteLine($"Caches:\n{string.Join("\n", success.Caches.Select(c => c.Name))}\n\n");
}
else if (result is ListCachesResponse.Error error)
{
throw new Exception($"An error occurred while attempting to list caches: {error.ErrorCode}: {error}");
}
$list_caches_response = $cache_client->listCaches();
if ($caches = $list_caches_response->asSuccess()) {
print("Found caches:\n");
foreach ($caches as $cache) {
$cache_name = $cache->name();
print("- $cache_name\n");
}
} elseif ($err = $list_caches_response->asError()) {
print("An error occurred while attempting to list caches: {$err->errorCode()} - {$err->message()}\n");
}
case Momento.CacheClient.list_caches(client) do
{:ok, result} ->
IO.puts("Caches:")
IO.inspect(result.caches)
{:error, error} ->
IO.puts("An error occurred while attempting to list caches: #{error.error_code}")
raise error
end
Flush cache
cacheの全データをフラッシュします。
属性:
名前 | 型 | 説明 |
---|---|---|
cacheName | String | フラッシュするcacheの名前。 |
- JavaScript
- Java
- C#
const result = await cacheClient.flushCache('test-cache');
if (result instanceof CacheFlush.Success) {
console.log("Cache 'test-cache' flushed");
} else if (result instanceof CacheFlush.Error) {
throw new Error(
`An error occurred while attempting to flush cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
final CacheFlushResponse response = cacheClient.flushCache("test-cache").join();
if (response instanceof CacheFlushResponse.Success) {
System.out.println("Cache 'test-cache' flushed");
} else if (response instanceof CacheFlushResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to flush cache 'test-cache': " + error.getErrorCode(),
error);
}
var result = await cacheClient.FlushCacheAsync("test-cache");
if (result is FlushCacheResponse.Success)
{
Console.WriteLine("Cache 'test-cache' flushed");
}
else if (result is FlushCacheResponse.Error error)
{
throw new Exception($"An error occurred while attempting to flush cache 'test-cache': {error.ErrorCode}: {error}");
}
:::ヒント
Delete Cache、Create Cacheの順に使用することでこのプロセスを模倣できますが、FlushCache APIはcacheの設定を保持したまま、データのみを削除します。
:::
データAPI
これらのAPIメソッドは、cache内のデータを直接操作するために使用されます。
Set
指定された生存時間(TTL)秒の値をcacheに設定します。このkeyの値がすでに存在する場合は、新しい値で置き換えられます。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | []Byte | 値を追加するkey。 |
value | []Byte | 格納される値。 |
ttlSeconds | int | cache内のアイテムのTTL。 |
- JavaScript
- Python
- Java
- Go
- C#
- PHP
- Elixir
const result = await cacheClient.set('test-cache', 'test-key', 'test-value');
if (result instanceof CacheSet.Success) {
console.log("Key 'test-key' stored successfully");
} else if (result instanceof CacheSet.Error) {
throw new Error(
`An error occurred while attempting to store key 'test-key' in cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
set_response = await cache_client.set('test-cache', 'test-key', 'test-value')
match set_response:
case CacheSet.Success():
print("Key 'test-key' stored successfully")
case CacheSet.Error() as error:
raise Exception(
f"An error occurred while attempting to store key 'test-key' in cache 'test-cache': {error.message}"
)
final SetResponse response = cacheClient.set("test-cache", "test-key", "test-value").join();
if (response instanceof SetResponse.Success) {
System.out.println("Key 'test-key' stored successfully");
} else if (response instanceof SetResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to store key 'test-key' in cache 'test-cache': "
+ error.getErrorCode(),
error);
}
key := uuid.NewString()
value := uuid.NewString()
log.Printf("Setting key: %s, value: %s\n", key, value)
_, err := client.Set(ctx, &momento.SetRequest{
CacheName: "cache-name",
Key: momento.String(key),
Value: momento.String(value),
Ttl: time.Duration(9999),
})
if err != nil {
var momentoErr momento.MomentoError
if errors.As(err, &momentoErr) {
if momentoErr.Code() != momento.TimeoutError {
// this would represent a client-side timeout, and you could fall back to your original data source
} else {
panic(err)
}
}
}
var result = await cacheClient.SetAsync("test-cache", "test-key", "test-value");
if (result is CacheSetResponse.Success)
{
Console.WriteLine("Key 'test-key' stored successfully");
}
else if (result is CacheSetResponse.Error error)
{
throw new Exception($"An error occurred while attempting to store key 'test-key' in cache 'test-cache': {error.ErrorCode}: {error}");
}
$set_response = $cache_client->set("test-cache", "test-key", "test-value");
if ($set_response->asSuccess()) {
print("Key 'test-key' stored successfully\n");
} elseif ($err = $set_response->asError()) {
print("An error occurred while attempting to store 'test-key': {$err->errorCode()} - {$err->message()}\n");
}
case Momento.CacheClient.set(client, "test-cache", "test-key", "test-value") do
{:ok, _} ->
IO.puts("Key 'test-key' stored successfully")
{:error, error} ->
IO.puts(
"An error occurred while attempting to store key 'test-key' in cache 'test-cache': #{error.error_code}"
)
raise error
end
Get
指定されたkeyに対して格納されているcache値を取得します。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | []Byte | 値を取得するために指定するkeyです。 |
- JavaScript
- Python
- Java
- Go
- C#
- PHP
- Elixir
const result = await cacheClient.get('test-cache', 'test-key');
if (result instanceof CacheGet.Hit) {
console.log(`Retrieved value for key 'test-key': ${result.valueString()}`);
} else if (result instanceof CacheGet.Miss) {
console.log("Key 'test-key' was not found in cache 'test-cache'");
} else if (result instanceof CacheGet.Error) {
throw new Error(
`An error occurred while attempting to get key 'test-key' from cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
get_response = await cache_client.get('test-cache', 'test-key')
match get_response:
case CacheGet.Hit() as hit:
print(f"Retrieved value for key 'test-key': {hit.value_string}")
case CacheGet.Miss():
print("Key 'test-key' was not found in cache 'test-cache'")
case CacheGet.Error() as error:
raise Exception(
f"An error occurred while attempting to get key 'test-key' from cache 'test-cache': {error.message}"
)
final GetResponse response = cacheClient.get("test-cache", "test-key").join();
if (response instanceof GetResponse.Hit hit) {
System.out.println("Retrieved value for key 'test-key': " + hit.valueString());
} else if (response instanceof GetResponse.Miss) {
System.out.println("Key 'test-key' was not found in cache 'test-cache'");
} else if (response instanceof GetResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to get key 'test-key' from cache 'test-cache': "
+ error.getErrorCode(),
error);
}
key := uuid.NewString()
resp, err := client.Get(ctx, &momento.GetRequest{
CacheName: "cache-name",
Key: momento.String(key),
})
if err != nil {
panic(err)
}
switch r := resp.(type) {
case *responses.GetHit:
log.Printf("Lookup resulted in cache HIT. value=%s\n", r.ValueString())
case *responses.GetMiss:
log.Printf("Look up did not find a value key=%s", key)
}
var result = await cacheClient.GetAsync("test-cache", "test-key");
if (result is CacheGetResponse.Hit hit)
{
Console.WriteLine($"Retrieved value for key 'test-key': {hit.ValueString}");
}
else if (result is CacheGetResponse.Miss)
{
Console.WriteLine("Key 'test-key' was not found in cache 'test-cache'");
}
else if (result is CacheGetResponse.Error error)
{
throw new Exception($"An error occurred while attempting to get key 'test-key' from cache 'test-cache': {error.ErrorCode}: {error}");
}
$get_response = $cache_client->get("test-cache", "test-key");
if ($hit = $get_response->asHit()) {
print("Retrieved value for key 'test-key': {$hit->valueString()}\n");
} elseif ($get_response->asMiss()) {
print("Key 'test-key' was not found in cache 'test-cache'\n");
} elseif ($err = $get_response->asError()) {
print("An error occurred while attempting to get key 'test-key' from cache 'test-cache': {$err->errorCode()} - {$err->message()}\n");
}
case Momento.CacheClient.get(client, "test-cache", "test-key") do
{:ok, hit} ->
IO.puts("Retrieved value for key 'test-key': #{hit.value}")
:miss ->
IO.puts("Key 'test-key' was not found in cache 'test-cache'")
{:error, error} ->
IO.puts(
"An error occurred while attempting to get key 'test-key' from cache 'test-cache': #{error.error_code}"
)
raise error
end
Delete
与えられたkeyに対して格納されているcache値を削除します。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | []Byte | 値を削除するために指定するkey。 |
- JavaScript
- Python
- Java
- Go
- C#
- PHP
- Elixir
const result = await cacheClient.delete('test-cache', 'test-key');
if (result instanceof CacheDelete.Success) {
console.log("Key 'test-key' deleted successfully");
} else if (result instanceof CacheDelete.Error) {
throw new Error(
`An error occurred while attempting to delete key 'test-key' from cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
delete_response = await cache_client.delete('test-cache', 'test-key')
match delete_response:
case CacheDelete.Success():
print("Key 'test-key' deleted successfully")
case CacheDelete.Error() as error:
raise Exception(f"An error occurred while attempting to delete key 'test-key' from cache 'test-cache': {error.message}")
final DeleteResponse response = cacheClient.delete("test-cache", "test-key").join();
if (response instanceof DeleteResponse.Success) {
System.out.println("Key 'test-key' deleted successfully");
} else if (response instanceof DeleteResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to delete key 'test-key' from cache 'test-cache': "
+ error.getErrorCode(),
error);
}
key := uuid.NewString()
_, err := client.Delete(ctx, &momento.DeleteRequest{
CacheName: "cache-name",
Key: momento.String(key),
})
if err != nil {
panic(err)
}
var result = await cacheClient.DeleteAsync("test-cache", "test-key");
if (result is CacheDeleteResponse.Success)
{
Console.WriteLine("Key 'test-key' deleted successfully");
}
else if (result is CacheDeleteResponse.Error error)
{
throw new Exception($"An error occurred while attempting to delete key 'test-key' from cache 'test-cache': {error.ErrorCode}: {error}");
}
$delete_response = $cache_client->delete("test-cache", "test-key");
if ($delete_response->asSuccess()) {
print("Key 'test-key' deleted successfully\n");
} elseif ($err = $delete_response->asError()) {
print("An error occurred while attempting to delete key 'test-key' from cache 'test-cache': {$err->errorCode()} - {$err->message()}\n");
}
case Momento.CacheClient.delete(client, "test-cache", "test-key") do
{:ok, _} ->
IO.puts("Key 'test-key' deleted successfully")
{:error, error} ->
IO.puts(
"An error occurred while attempting to delete key 'test-key' from cache 'test-cache': #{error.error_code}"
)
raise error
end
Increment
既存の値がベース10(10進法)の整数を表すUTF-8文字列である場合に限り、フィールドの値を追加 します。もしフィールドが存在しない場合、このメソッドはフィールドの値をインクリメントして設定しま す。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
field | String | 値のインクリメントする場合の対象となるkey。 |
amount | Integer | 値に加算する量です。正の値、負の値、またはゼロを指定します。デフォルトは1。 |
:::注記
インクリメントされた値は、-9223372036854775808から9223372036854775807の間、つまり64ビッ ト符号付き整数配列でなければなりません。そうでない場合は、エラーが返されます。
:::
- JavaScript
- Java
await cacheClient.set('test-cache', 'test-key', '10');
const result = await cacheClient.increment('test-cache', 'test-key', 1);
if (result instanceof CacheIncrement.Success) {
console.log(`Key 'test-key' incremented successfully. New value in key test-key: ${result.valueNumber()}`);
} else if (result instanceof CacheIncrement.Error) {
throw new Error(
`An error occurred while attempting to increment the value of key 'test-key' from cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
cacheClient.set("test-cache", "test-key", "10").join();
final IncrementResponse response = cacheClient.increment("test-cache", "test-key", 1).join();
if (response instanceof IncrementResponse.Success success) {
System.out.println(
"Key 'test-key' incremented successfully. New value in key test-key: "
+ success.valueNumber());
} else if (response instanceof IncrementResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to increment the value of key 'test-key' from cache 'test-cache': "
+ error.getErrorCode(),
error);
}
Ping
サーバにpingを送信します。このAPIは、クライアントがサーバに正常に接続できることを確認するた めの接続性のチェックに使用できます。
メソッドのレスポンスオブジェクト
- Success
- Error
具体的な情報については、レスポンスオブジェクトを参照してください。
ItemGetType
与えられたkeyに対して、対応するアイテムが存在する場合、その型(SCALAR、DICTIONARY、LISTな ど)を返します。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | String | Byte | itemの型が返却されるべきkey。 |
メソッドのレスポンスオブジェクト
- Cache hit
型()
: enum: SCALAR, DICTIONARY, SET, LIST, SORTED_SET
Cache miss
Cache error
具体的な情報については、レスポンスオブジェクトを参照してください。
- JavaScript
const result = await cacheClient.itemGetType('test-cache', 'test-key');
if (result instanceof CacheItemGetType.Hit) {
console.log(`Item type retrieved successfully: ${ItemType[result.itemType()]}`);
} else if (result instanceof CacheItemGetType.Miss) {
console.log("Key 'test-key' was not found in cache 'test-cache'");
} else if (result instanceof CacheItemGetType.Error) {
throw new Error(
`An error occurred while attempting to get the type of key 'test-key' from cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
KeyExists
指定されたkeyがcacheに存在するかどうかをチェックします。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | String | Byte | cacheに存在するかどうかをチェックするkey。 |
メソッドのレスポンスオブジェクト
KeysExist
指定されたkey(複数)がcacheに存在するかどうかをチェックします。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
keys | String[] | Byte[] | cacheに存在するかどうかをチェックするkey(複数)。 |
メソッドのレスポンスオブジェクト
SetIfNotExists
指定された値を、指定されたkeyを持つcacheのアイテムに関連付けます。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | String | Bytes | 設定されるkey。 |
value | String | Bytes | 格納される値。 |
ttlSeconds | Duration | cacheにあるアイテムの生存時間 (TTL)。 |
メソッドのレスポンスオブジェクト
- Stored
- NotStored
- Error
具体的な情報については、レスポンスオブジェクトを参照してください。
- JavaScript
- Java
const result = await cacheClient.setIfNotExists('test-cache', 'test-key', 'test-field');
if (result instanceof CacheSetIfNotExists.Stored) {
console.log("Field 'test-field' set in key 'test-key'");
} else if (result instanceof CacheSetIfNotExists.NotStored) {
console.log("Key 'test-key' already exists in cache 'test-cache', so we did not overwrite it");
} else if (result instanceof CacheSetIfNotExists.Error) {
throw new Error(
`An error occurred while attempting to call setIfNotExists for the key 'test-key' in cache 'test-cache': ${result.errorCode()}: ${result.toString()}`
);
}
final SetIfNotExistsResponse response =
cacheClient.setIfNotExists("test-cache", "test-key", "test-field").join();
if (response instanceof SetIfNotExistsResponse.Stored) {
System.out.println("Field 'test-field' set in key 'test-key'");
} else if (response instanceof SetIfNotExistsResponse.NotStored) {
System.out.println(
"Key 'test-key' already exists in cache 'test-cache', so we did not overwrite it");
} else if (response instanceof SetIfNotExistsResponse.Error error) {
throw new RuntimeException(
"An error occurred while attempting to call setIfNotExists for the key 'test-key' in cache 'test-cache': "
+ error.getErrorCode(),
error);
}
生存時間(TTL)API
これらのAPIは、すべての型のcacheに適用されます。
UpdateTtl
cacheアイテムのTTLを、指定された値(秒)で上書きします。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | String | Bytes | 値のTTLを上書きする対象のkey。 |
ttl | Duration | cacheで上書きしたいTTLを秒単位で指定します。 |
IncreaseTtl
TTLを増加させる場合のみ、keyのTTL秒数を指定された値に増やします。
例
- TTLが5秒で、6秒を指定した場合、新しいTTLは6秒になります。
- TTLが5秒で、3秒を指定した場合、TTLは増加しません。 | 名前 | 型 | 説明 | | --------- | ------ | ----------------------------------------------- | | cacheName | String | cacheの名前。 | | | key | String | Bytes | 値のTTLを増加させるkeyの指定。 | | ttl | Duration | 増加したいTTLを秒単位で指定します。 |
DecreaseTtl
TTLを減少させる場合のみ、keyのTTL秒数を指定された値に減らします。
例
- TTLが5秒で、3秒を指定した場合、新しいTTLは3秒になります。
- TTLが5秒で、6秒を指定した場合、TTLは減少しません。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | String | Bytes | 値のTTLを減少させるkeyの指定。 |
ttl | Duration | 減少させたいTTLを秒単位で指定します。 |
ItemGetTtl
与えられたkeyに対して、そのアイテムがcacheから失効するまでの生存時間(TTL)を返します。
名前 | 型 | 説明 |
---|---|---|
cacheName | String | cacheの名前。 |
key | String | Byte | アイテムの型を返すkeyの指定。 |
メソッドのレスポンスオブジェクト
認証API
これらのAPIは、Momentoの認証トークンやアクセスを管理するために使用されます。
GenerateAuthToken
指定した権限と有効期限を持つ新しいMomento認証トークンを生成します。
名前 | 型 | 説明 |
---|---|---|
scope | TokenScope | 新しいトークンに付与する権限です。あらかじめ構築されたTokenScope オブジェクトは、SDKによって提供されます。 |
expiresIn | ExpiresIn | トークンが期限切れになるまでの秒数、またはnever の指定。 |
メソッドのレスポンスオブジェクト
- Success
authToken
: string - the new auth tokenrefreshToken
: string - a refresh token that can be used with theRefreshAuthToken
API to refresh the token before it expiresexpiresAt
: Timestamp - the timestamp at which the token will expire
- Error
具体的な情報については、レスポンスオブジェクトを参照してください。
RefreshAuthToken
既存の有効期限内のMomento認証トークンを更新します。元のトークンと同じ権限と有効期限を持つ 新しいトークンを生成します。
名前 | 型 | 説明 |
---|---|---|
refreshToken | String | 最初のGenerateAuthToken の呼び出しから取得した、現在の認証トー クンのrefreshTokenを指定。 |
メソッドのレスポンスオブジェクト
- Success
authToken
: string - the new auth tokenrefreshToken
: string - a refresh token that can be used with theRefreshAuthToken
API to refresh the token before it expiresexpiresAt
: Timestamp - the timestamp at which the token will expire
- Error
具体的な情報については、レスポンスオブジェクトを参照してください。
コレクションデータ型
コレクション型は、ユースケースに応じて、さまざまなタイプの構造を含むことができます。サポートされ ているデータ型は以下の通りです:
- Dictionaries(辞書型)は、順序のないフィールドと値のペアを格納するために使用されます。
- Lists(リスト型)は、順序付けられた要素のコレクションで、各要素が挿入された順序でソートされています。
- Sets(セット型)は、ユニークな要素の文字列による、順序のないコレクションです。
- Sorted Sets(ソート済みセット型) は、ユニークな要素の順序付きコレクションです。各要素 は、値:スコアのペアを含んでいます。
利用方法についての詳しい情報は、コレクションデータ型をご覧ください。
現在のSDKのAPI対応状況について
各SDKの言語におけるAPIサポートの状況については、言語サポートページをご覧ください。