Data Grid REST API

さまざまな形式でデータの書き込みと読み取りを行うことができ、Data Grid は必要に応じてそれらの形式間で変換できます。

次の "標準" フォーマットは交換可能です。

上記のデータ形式を次の形式に変換することもできます。

Data Grid では、application/x-protostream と application/json の間で変換することもできます。

REST API へのすべての呼び出しは、書き込まれたコンテンツまたは読み取るときに必要なコンテンツの形式を説明するヘッダーを提供できます。Data Grid は、値に適用される標準的な HTTP/1.1 ヘッダーの "Content-Type "と "Accept "に加えて、キーに同様の効果を持つ "Key-Content-Type "をサポートしています。

Data Grid REST エンドポイントは RFC-2616 Accept ヘッダーに準拠しており、サポートされている変換に基づいて正しい MediaType をネゴシエートします。

例えば、データ読み込み時に次のようなヘッダーを送信します。

Accept: text/plain;q=0.7, application/json;q=0.8, */*;q=0.6

上記のヘッダーにより、Data Grid は最初にコンテンツを JSON 形式 (優先度 0.8) で返します。保存形式を JSON に変換できない場合、Data Grid は次の形式である text/plain を試みます (2 番目に高い優先度 0.7)。最後に、Data Grid は*/*にフォールバックし、キャッシュの設定に基づいて適切なフォーマットを選択します。

REST リソースの作成には、URL の一部となる名前が必要です。この名前に RFC 3986 仕様のセクション 2.2 で定義されている特殊文字が含まれている場合には、Percent encoding メカニズムでエンコードする必要があります。

ほとんどの REST API コールでは、URL に Key が含まれています。Data Grid は、これらの呼び出しを処理する際に、Key がjava.lang.Stringであることを前提としていますが、異なるフォーマットのキーに対しては、特定のヘッダーKey-Content-Typeを使用することができます。

API 呼び出し:

`PUT /my-cache/AQIDBDM=`

ヘッダー:

Key-Content-Type: application/octet-stream

API 呼び出し:

GET /my-cache/0x01CA03042F

ヘッダー:

Key-Content-Type: application/octet-stream; encoding=hex

API 呼び出し:

POST /my-cache/3.141456

ヘッダー:

Key-Content-Type: application/x-java-object;type=java.lang.Double

application / x-java-object の type パラメーターは次のように制限されています。

キャッシュがインデックス化されている場合や、application/x-protostream を保存するように特別に設定されている場合、Protobuf との間で自動的に変換された JSON ドキュメントを送受信することができます。

変換を機能させるには、Protobuf スキーマを登録する必要があります。

REST 経由で protobuf スキーマを登録するには、次の例のように、POST または PUT を起動して ___protobuf_metadata キャッシュを起動します。

curl -u user:password -X POST --data-binary @./schema.proto http://127.0.0.1:11222/rest/v2/caches/___protobuf_metadata/schema.proto

JSON ドキュメントを記述する際には、ドキュメントに対応する Protobuf Message を識別するための特別なフィールド _type は、ドキュメントに対応する Protobuf Messageを識別するために、ドキュメント内に存在する必要があります。

message Person  {
  required string name = 1;
  required int32 age = 2;
}

{
   "_type": "Person",
   "name": "user1",
   "age": 32
}

VM プロパティーの infinispan.server.rest.cors-allow は、サーバーの起動時に使用して、1 つまたは複数のオリジンにすべてのパーミッションを許可することができます。以下に例を示します。

./bin/server.sh -Dinfinispan.server.rest.cors-allow=http://192.168.1.78:11222,http://host.mydomain.com

この方法を使用して指定されたすべてのオリジンは、設定されたルールよりも優先されます。

XML または JSON 設定をペイロードに含む POST リクエストで、Data Grid クラスター全体に名前付きキャッシュを作成します。

POST /rest/v2/caches/{cacheName}

<distributed-cache owners="2"
                   segments="256"
                   capacity-factor="1.0"
                   l1-lifespan="5000"
                   mode="SYNC"
                   statistics="true">
  <encoding media-type="application/x-protostream"/>
  <locking isolation="REPEATABLE_READ"/>
  <transaction mode="FULL_XA"
               locking="OPTIMISTIC"/>
  <expiration lifespan="5000"
              max-idle="1000" />
  <memory max-count="1000000"
          when-full="REMOVE"/>
  <indexing enabled="true"
            storage="local-heap">
    <index-reader refresh-interval="1000"/>
    <indexed-entities>
      <indexed-entity>org.infinispan.Person</indexed-entity>
    </indexed-entities>
  </indexing>
  <partition-handling when-split="ALLOW_READ_WRITES"
                      merge-policy="PREFERRED_NON_NULL"/>
  <persistence passivation="false">
    <!-- Persistent storage configuration. -->
  </persistence>
</distributed-cache>

{
  "distributed-cache": {
    "mode": "SYNC",
    "owners": "2",
    "segments": "256",
    "capacity-factor": "1.0",
    "l1-lifespan": "5000",
    "statistics": "true",
    "encoding": {
      "media-type": "application/x-protostream"
    },
    "locking": {
      "isolation": "REPEATABLE_READ"
    },
    "transaction": {
      "mode": "FULL_XA",
      "locking": "OPTIMISTIC"
    },
    "expiration" : {
      "lifespan" : "5000",
      "max-idle" : "1000"
    },
    "memory": {
      "max-count": "1000000",
      "when-full": "REMOVE"
    },
    "indexing" : {
          "enabled" : true,
          "storage" : "local-heap",
          "index-reader" : {
            "refresh-interval" : "1000"
          },
          "indexed-entities": [
            "org.infinispan.Person"
          ]
    },
    "partition-handling" : {
      "when-split" : "ALLOW_READ_WRITES",
      "merge-policy" : "PREFERRED_NON_NULL"
    },
    "persistence" : {
      "passivation" : false
    }
  }
}

distributedCache:
  mode: "SYNC"
  owners: "2"
  segments: "256"
  capacityFactor: "1.0"
  l1Lifespan: "5000"
  statistics: "true"
  encoding:
    mediaType: "application/x-protostream"
  locking:
    isolation: "REPEATABLE_READ"
  transaction:
    mode: "FULL_XA"
    locking: "OPTIMISTIC"
  expiration:
    lifespan: "5000"
    maxIdle: "1000"
  memory:
    maxCount: "1000000"
    whenFull: "REMOVE"
  indexing:
    enabled: "true"
    storage: "local-heap"
    indexReader:
      refreshInterval: "1000"
    indexedEntities:
      - "org.infinispan.Person"
  partitionHandling:
    whenSplit: "ALLOW_READ_WRITES"
    mergePolicy: "PREFERRED_NON_NULL"
  persistence:
    passivation: "false"
    # Persistent storage configuration.

<replicated-cache segments="256"
                  mode="SYNC"
                  statistics="true">
  <encoding media-type="application/x-protostream"/>
  <locking isolation="REPEATABLE_READ"/>
  <transaction mode="FULL_XA"
               locking="OPTIMISTIC"/>
  <expiration lifespan="5000"
              max-idle="1000" />
  <memory max-count="1000000"
          when-full="REMOVE"/>
  <indexing enabled="true"
            storage="local-heap">
    <index-reader refresh-interval="1000"/>
    <indexed-entities>
      <indexed-entity>org.infinispan.Person</indexed-entity>
    </indexed-entities>
  </indexing>
  <partition-handling when-split="ALLOW_READ_WRITES"
                      merge-policy="PREFERRED_NON_NULL"/>
  <persistence passivation="false">
    <!-- Persistent storage configuration. -->
  </persistence>
</replicated-cache>

{
  "replicated-cache": {
    "mode": "SYNC",
    "segments": "256",
    "statistics": "true",
    "encoding": {
      "media-type": "application/x-protostream"
    },
    "locking": {
      "isolation": "REPEATABLE_READ"
    },
    "transaction": {
      "mode": "FULL_XA",
      "locking": "OPTIMISTIC"
    },
    "expiration" : {
      "lifespan" : "5000",
      "max-idle" : "1000"
    },
    "memory": {
      "max-count": "1000000",
      "when-full": "REMOVE"
    },
    "indexing" : {
      "enabled" : true,
      "storage" : "local-heap",
      "index-reader" : {
        "refresh-interval" : "1000"
        },
      "indexed-entities": [
        "org.infinispan.Person"
      ]
    },
    "partition-handling" : {
      "when-split" : "ALLOW_READ_WRITES",
      "merge-policy" : "PREFERRED_NON_NULL"
    },
    "persistence" : {
      "passivation" : false
    }
  }
}

replicatedCache:
  mode: "SYNC"
  segments: "256"
  statistics: "true"
  encoding:
    mediaType: "application/x-protostream"
  locking:
    isolation: "REPEATABLE_READ"
  transaction:
    mode: "FULL_XA"
    locking: "OPTIMISTIC"
  expiration:
    lifespan: "5000"
    maxIdle: "1000"
  memory:
    maxCount: "1000000"
    whenFull: "REMOVE"
  indexing:
    enabled: "true"
    storage: "local-heap"
    indexReader:
      refreshInterval: "1000"
    indexedEntities:
      - "org.infinispan.Person"
  partitionHandling:
    whenSplit: "ALLOW_READ_WRITES"
    mergePolicy: "PREFERRED_NON_NULL"
  persistence:
    passivation: "false"
    # Persistent storage configuration.

<infinispan
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="urn:infinispan:config:15.0 https://infinispan.org/schemas/infinispan-config-15.0.xsd
                          urn:infinispan:server:15.0 https://infinispan.org/schemas/infinispan-server-15.0.xsd"
      xmlns="urn:infinispan:config:15.0"
      xmlns:server="urn:infinispan:server:15.0">
  <cache-container name="default"
                   statistics="true">
    <distributed-cache name="mycacheone"
                       mode="ASYNC"
                       statistics="true">
      <encoding media-type="application/x-protostream"/>
      <expiration lifespan="300000"/>
      <memory max-size="400MB"
              when-full="REMOVE"/>
    </distributed-cache>
    <distributed-cache name="mycachetwo"
                       mode="SYNC"
                       statistics="true">
      <encoding media-type="application/x-protostream"/>
      <expiration lifespan="300000"/>
      <memory max-size="400MB"
              when-full="REMOVE"/>
    </distributed-cache>
  </cache-container>
</infinispan>

{
  "infinispan" : {
    "cache-container" : {
      "name" : "default",
      "statistics" : "true",
      "caches" : {
        "mycacheone" : {
          "distributed-cache" : {
            "mode": "ASYNC",
            "statistics": "true",
            "encoding": {
              "media-type": "application/x-protostream"
            },
            "expiration" : {
              "lifespan" : "300000"
            },
            "memory": {
              "max-size": "400MB",
              "when-full": "REMOVE"
            }
          }
        },
        "mycachetwo" : {
          "distributed-cache" : {
            "mode": "SYNC",
            "statistics": "true",
            "encoding": {
              "media-type": "application/x-protostream"
            },
            "expiration" : {
              "lifespan" : "300000"
            },
            "memory": {
              "max-size": "400MB",
              "when-full": "REMOVE"
            }
          }
        }
      }
    }
  }
}

infinispan:
  cacheContainer:
    name: "default"
    statistics: "true"
    caches:
      mycacheone:
       distributedCache:
          mode: "ASYNC"
          statistics: "true"
          encoding:
            mediaType: "application/x-protostream"
          expiration:
            lifespan: "300000"
          memory:
            maxSize: "400MB"
            whenFull: "REMOVE"
      mycachetwo:
        distributedCache:
          mode: "SYNC"
          statistics: "true"
          encoding:
            mediaType: "application/x-protostream"
          expiration:
            lifespan: "300000"
          memory:
            maxSize: "400MB"
            whenFull: "REMOVE"

ペイロードに XML または JSON 設定を含む PUT リクエストを使用して、Data Grid クラスター全体のキャッシュ設定の属性を変更します。

PUT /rest/v2/caches/{cacheName}

HEAD リクエストを使用して、Data Grid クラスターにキャッシュが存在するか確認します。

HEAD /rest/v2/caches/{cacheName}

GET リクエストでキャッシュの健全性を取得します。

GET /rest/v2/caches/{cacheName}?action=health

POST リクエストと ?template= パラメーターを使用して、Data Grid テンプレートからキャッシュを作成します。

POST /rest/v2/caches/{cacheName}?template={templateName}

GET リクエストで Data Grid のキャッシュ設定を取得します。

GET /rest/v2/caches/{name}?action=config

有効な設定と ?action=convert パラメーターを使用して POST リクエストを呼び出します。Data Grid は、Accept ヘッダで指定されたタイプの設定の同等の表現で応答します。

POST /rest/v2/caches?action=convert

キャッシュ設定を変換するには、Content-Type ヘッダーで設定の入力形式を指定し、Accept ヘッダーで目的の出力形式を指定する必要があります。たとえば、次のコマンドは、レプリケートされたキャッシュ設定を XML から YAML に変換します。

curl localhost:11222/rest/v2/caches?action=convert \
--digest -u username:password \
-X POST -H "Accept: application/yaml" -H "Content-Type: application/xml" \
-d '<replicated-cache mode="SYNC" statistics="false"><encoding media-type="application/x-protostream"/><expiration lifespan="300000" /><memory max-size="400MB" when-full="REMOVE"/></replicated-cache>'

2 つのキャッシュ設定と ?action=compare パラメーターを含む multipart/form-data 本体で POST 要求を呼び出します。

POST /rest/v2/caches?action=compare

Data Grid は、設定が等しい場合は 204 (No Content) で応答し、設定が異なる場合は 409 (Conflict) で応答します。

GET リクエストを呼び出し、Data Grid キャッシュのすべての詳細を取得します。

GET /rest/v2/caches/{name}?action=stats

Data Grid は、以下のような JSON レスポンスを提供します。

 {
  "stats": {
    "time_since_start": -1,
    "time_since_reset": -1,
    "hits": -1,
    "current_number_of_entries": -1,
    "current_number_of_entries_in_memory": -1,
    "stores": -1,
    "off_heap_memory_used": -1,
    "data_memory_used": -1,
    "retrievals": -1,
    "misses": -1,
    "remove_hits": -1,
    "remove_misses": -1,
    "evictions": -1,
    "average_read_time": -1,
    "average_read_time_nanos": -1,
    "average_write_time": -1,
    "average_write_time_nanos": -1,
    "average_remove_time": -1,
    "average_remove_time_nanos": -1,
    "required_minimum_number_of_nodes": -1
  },
  "size": 0,
  "configuration": {
    "distributed-cache": {
      "mode": "SYNC",
      "transaction": {
        "stop-timeout": 0,
        "mode": "NONE"
      }
    }
  },
  "rehash_in_progress": false,
  "rebalancing_enabled": true,
  "bounded": false,
  "indexed": false,
  "persistent": false,
  "transactional": false,
  "secured": false,
  "has_remote_backup": false,
  "indexing_in_progress": false,
  "statistics": false,
  "mode" : "DIST_SYNC",
  "storage_type": "HEAP",
  "max_size": "",
  "max_size_bytes" : -1
}

POST リクエストを呼び出して、Data Grid キャッシュのすべての統計情報をリセットします。

POST /rest/v2/caches/{name}?action=stats-reset

GET 要求を呼び出して、Data Grid キャッシュのデータ配布に関するすべての詳細を取得します。

GET /rest/v2/caches/{name}?action=distribution

Data Grid は、以下のような JSON レスポンスを提供します。

[
  {
    "node_name": "NodeA",
    "node_addresses": [
      "127.0.0.1:44175"
    ],
    "memory_entries": 0,
    "total_entries": 0,
    "memory_used": 528512
  },
  {
    "node_name":"NodeB",
    "node_addresses": [
      "127.0.0.1:44187"
    ],
    "memory_entries": 0,
    "total_entries": 0,
    "memory_used": 528512
  }
]

リスト内の各要素はノードを表します。プロパティーは次のとおりです。

GET 要求を呼び出して、Data Grid キャッシュのすべての可変キャッシュ設定属性を取得します。

GET /rest/v2/caches/{name}?action=get-mutable-attributes

Data Grid は、以下のような JSON レスポンスを提供します。

[
  "jmx-statistics.statistics",
  "locking.acquire-timeout",
  "transaction.single-phase-auto-commit",
  "expiration.max-idle",
  "transaction.stop-timeout",
  "clustering.remote-timeout",
  "expiration.lifespan",
  "expiration.interval",
  "memory.max-count",
  "memory.max-size"
]

値や型の情報を得るには、full パラメーターを追加します。

GET /rest/v2/caches/mycache?action=get-mutable-attributes&full=true

Data Grid は、以下のような JSON レスポンスを提供します。

{
  "jmx-statistics.statistics": {
    "value": true,
    "type": "boolean"
  },
  "locking.acquire-timeout": {
    "value": 15000,
    "type": "long"
  },
  "transaction.single-phase-auto-commit": {
    "value": false,
    "type": "boolean"
  },
  "expiration.max-idle": {
    "value": -1,
    "type": "long"
  },
  "transaction.stop-timeout": {
    "value": 30000,
    "type": "long"
  },
  "clustering.remote-timeout": {
    "value": 17500,
    "type": "long"
  },
  "expiration.lifespan": {
    "value": -1,
    "type": "long"
  },
  "expiration.interval": {
    "value": 60000,
    "type": "long"
  },
  "memory.max-count": {
    "value": -1,
    "type": "long"
  },
  "memory.max-size": {
    "value": null,
    "type": "string"
  }
}

enum 型の属性の場合、追加の universe プロパティーには、可能な値のセットが含まれます。

変更可能なキャッシュ設定属性を変更するために、POST リクエストを呼び出します。

POST /rest/v2/caches/{name}?action=set-mutable-attributes&attribute-name={attributeName}&attribute-value={attributeValue}

POST リクエストでキャッシュにエントリーを追加します。

POST /rest/v2/caches/{cacheName}/{cacheKey}

前述の要求は cacheKey キーで cacheName を指定のキャッシュに、ペイロード、またはリクエストボディを配置します。リクエストは、既存のデータを置き換え、適用可能であれば、Time-To-Live と Last-Modified の値を更新します。

エントリーが正常に作成されると、サービスは 204 (No Content) を返します。

指定されたキーにすでに値が存在する場合、POST リクエストは 409 (Conflict) を返し、値の変更は行いません。値を更新するには、PUT リクエストを使用する必要があります。エントリーの入れ替え をご覧ください。

キャッシュ内のエントリーを PUT リクエストに置き換えます。

PUT /rest/v2/caches/{cacheName}/{cacheKey}

指定されたキーの値がすでに存在する場合、PUT 要求は値を更新します。既存の値を変更したくない場合は、値を変更する代わりに、409 (Conflict) を返す POST リクエストを使用してください。値の追加 を参照してください。

GET リクエストを使用して特定のキーのデータを取得します。

GET /rest/v2/caches/{cacheName}/{cacheKey}

サーバーは、応答本文の指定されたキー cacheKey の下にある指定されたキャッシュ cacheName からデータを返します。応答には、MediaType ネゴシエーションに対応する Content-Type ヘッダーが含まれています。

GET /rest/v2/caches/{cacheName}/{cacheKey}?extended

HEAD リクエストで特定のエントリーが存在することを確認します。

HEAD /rest/v2/caches/{cacheName}/{cacheKey}

上記のリクエストは、ヘッダーフィールドと、エントリーとともに保存したものと同じコンテンツのみを返します。たとえば、文字列を保存した場合、リクエストは文字列を返します。バイナリー、base64 エンコード、blob、またはシリアル化された Java オブジェクトを保存した場合、Data Grid はリクエストのコンテンツを逆シリアル化しません。

DELETE リクエストを使用してキャッシュからエントリーを 削除 します。

DELETE /rest/v2/caches/{cacheName}/{cacheKey}

このエンドポイントを呼び出して、Data Grid キャッシュエントリーのデータ配布の詳細を取得します。

GET /rest/v2/caches/{cacheName}/{cacheKey}?action=distribution

Data Grid は、以下のような JSON レスポンスを提供します。

{
  "contains_key": true,
  "owners": [
    {
      "node_name": "NodeA",
      "primary": true,
      "node_addresses": [
        "127.0.0.1:39492"
      ]
    },
    {
      "node_name": "NodeB",
      "primary": false,
      "node_addresses": [
        "127.0.0.1:38195"
      ]
    }
  ]
}

所有者リストには次のプロパティーが含まれます。

DELETE リクエストを使用して Data Grid クラスターからキャッシュを DELETE 削除します。

DELETE /rest/v2/caches/{cacheName}

GET リクエストを呼び出して、キャッシュ内のすべてのキーを JSON 形式で取得します。

GET /rest/v2/caches/{cacheName}?action=keys

GET リクエストを呼び出し、キャッシュ内のすべてのエントリーを JSON 形式で取得します。

GET /rest/v2/caches/{cacheName}?action=entries

Data Grid は、以下のような JSON レスポンスを提供します。

[
    {
        "key": 1,
        "value": "value1",
        "timeToLiveSeconds": -1,
        "maxIdleTimeSeconds": -1,
        "created": -1,
        "lastUsed": -1,
        "expireTime": -1
    },
    {
        "key": 2,
        "value": "value2",
        "timeToLiveSeconds": 10,
        "maxIdleTimeSeconds": 45,
        "created": 1607966017944,
        "lastUsed": 1607966017944,
        "expireTime": 1607966027944,
        "version": 7
    },
    {
        "key": 3,
        "value": "value2",
        "timeToLiveSeconds": 10,
        "maxIdleTimeSeconds": 45,
        "created": 1607966017944,
        "lastUsed": 1607966017944,
        "expireTime": 1607966027944,
        "version": 7,
        "topologyId": 9
    }
]

キャッシュからすべてのデータを削除するには、POST リクエストに ?action=clear パラメーターを付けて実行します。

POST /rest/v2/caches/{cacheName}?action=clear

操作が正常に完了すると、サービスは 204 (No Content) を返します。

GET リクエストと ?action=size パラメーターを使用して、クラスター全体のキャッシュのサイズを取得します。

GET /rest/v2/caches/{cacheName}?action=size

GET リクエストを使用してキャッシュの実行時統計を取得します。

GET /rest/v2/caches/{cacheName}?action=stats

GET リクエストを使用して、Data Grid クラスターで使用可能なすべてのキャッシュをリスト表示します。

GET /rest/v2/caches/

GET リクエストを使用して、キャッシュマネージャーで使用可能なすべてのキャッシュのリストと、キャッシュのステータスおよび詳細を取得します。

GET /rest/v2/caches?action=detailed

Data Grid は、次の例のように、使用可能な各キャッシュをリスト表示して説明する JSON 配列で応答します。

[ {
  "status" : "RUNNING",
  "name" : "cache1",
  "type" : "local-cache",
  "simple_cache" : false,
  "transactional" : false,
  "persistent" : false,
  "bounded": false,
  "secured": false,
  "indexed": true,
  "has_remote_backup": true,
  "health":"HEALTHY",
  "rebalancing_enabled": true
}, {
  "status" : "RUNNING",
  "name" : "cache2",
  "type" : "distributed-cache",
  "simple_cache" : false,
  "transactional" : true,
  "persistent" : false,
  "bounded": false,
  "secured": false,
  "indexed": true,
  "has_remote_backup": true,
  "health":"HEALTHY",
  "rebalancing_enabled": false
}]

セキュリティーが有効な場合、ロールのアクセス可能なすべてのキャッシュのリストを取得します。この操作には ADMIN 権限が必要です。

GET /rest/v2/caches?action=role-accessible&role=observer

Data Grid は、次の例のように JSON で応答します。

{
  "secured" : ["securedCache1", "securedCache2"],
  "non-secured" : ["cache1", "cache2", "cache3"]
}

Server-Sent Events でキャッシュイベントを受信する。event 値は、cache-entry-created、cache-entry-removed、cache-entry-updated、cache-entry-expired のいずれかになります。data 値には、Accept ヘッダーで設定された形式でイベントを発生させたエントリーのキーが含まれます。

GET /rest/v2/caches/{name}?action=listen

特定のキャッシュの自動リバランスをオンにします。

POST /rest/v2/caches/{cacheName}?action=enable-rebalancing

特定のキャッシュの自動リバランスをオフにします。

POST /rest/v2/caches/{cacheName}?action=disable-rebalancing

キャッシュの可用性を取得します。

GET /rest/v2/caches/{cacheName}?action=get-availability

DENY_READ_WRITES または ALLOW_READS パーティション処理戦略のいずれかを使用する場合は、クラスター化されたキャッシュの可用性を変更します。

POST /rest/v2/caches/{cacheName}?action=set-availability&availability={AVAILABILITY}

デフォルトでは、クラスターのシャットダウン後、Data Grid はすべてのノードがクラスターに参加してトポロジーを復元するまで待機します。ただし、REST 操作を使用して、特定のキャッシュに対して現在のクラスタートポロジーを安定として定義できます。

POST /rest/v2/caches/{cacheName}?action=initialize&force={FORCE}

HTTP クライアントから GET リクエストと ?action=search&query パラメーターを使用して、リモートキャッシュにクエリーを実行します。

GET /rest/v2/caches/{cacheName}?action=search&query={ickle query}

{
  "hit_count" : 150,
  "hit_count_exact" : true,
  "hits" : [ {
    "hit" : {
      "name" : "user1",
      "age" : 35
    }
  }, {
    "hit" : {
       "name" : "user2",
       "age" : 42
    }
  }, {
    "hit" : {
       "name" : "user3",
       "age" : 12
    }
  } ]
}

クエリーパラメーターを指定せずにリクエストの本文を使用するには、以下のように POST リクエストを呼び出します。

POST /rest/v2/caches/{cacheName}?action=search

{
 "query":"from Entity where name:\"user1\"",
 "max_results":20,
 "offset":10
}

POST /rest/v2/caches/{cacheName}/search/indexes?action=reindex

POST /rest/v2/caches/{cacheName}/search/indexes?action=updateSchema

POST /rest/v2/caches/{cacheName}/search/indexes?action=clear

GET /rest/v2/caches/{cacheName}/search/indexes/metamodel

[{
    "entity-name": "org.infinispan.query.test.Book",
    "java-class": "org.infinispan.query.test.Book",
    "index-name": "org.infinispan.query.test.Book",
    "value-fields": {
        "description": {
            "multi-valued": false,
            "multi-valued-in-root": false,
            "type": "java.lang.String",
            "projection-type": "java.lang.String",
            "argument-type": "java.lang.String",
            "searchable": true,
            "sortable": false,
            "projectable": false,
            "aggregable": false,
            "analyzer": "standard"
        },
        "name": {
            "multi-valued": false,
            "multi-valued-in-root": true,
            "type": "java.lang.String",
            "projection-type": "java.lang.String",
            "argument-type": "java.lang.String",
            "searchable": true,
            "sortable": false,
            "projectable": false,
            "aggregable": false,
            "analyzer": "standard"
        },
        "surname": {
            "multi-valued": false,
            "multi-valued-in-root": true,
            "type": "java.lang.String",
            "projection-type": "java.lang.String",
            "argument-type": "java.lang.String",
            "searchable": true,
            "sortable": false,
            "projectable": false,
            "aggregable": false
        },
        "title": {
            "multi-valued": false,
            "multi-valued-in-root": false,
            "type": "java.lang.String",
            "projection-type": "java.lang.String",
            "argument-type": "java.lang.String",
            "searchable": true,
            "sortable": false,
            "projectable": false,
            "aggregable": false
        }
    },
    "object-fields": {
        "authors": {
            "multi-valued": true,
            "multi-valued-in-root": true,
            "nested": true,
            "value-fields": {
                "name": {
                    "multi-valued": false,
                    "multi-valued-in-root": true,
                    "type": "java.lang.String",
                    "projection-type": "java.lang.String",
                    "argument-type": "java.lang.String",
                    "searchable": true,
                    "sortable": false,
                    "projectable": false,
                    "aggregable": false,
                    "analyzer": "standard"
                },
                "surname": {
                    "multi-valued": false,
                    "multi-valued-in-root": true,
                    "type": "java.lang.String",
                    "projection-type": "java.lang.String",
                    "argument-type": "java.lang.String",
                    "searchable": true,
                    "sortable": false,
                    "projectable": false,
                    "aggregable": false
                }
            }
        }
    }
}, {
    "entity-name": "org.infinispan.query.test.Author",
    "java-class": "org.infinispan.query.test.Author",
    "index-name": "org.infinispan.query.test.Author",
    "value-fields": {
        "surname": {
            "multi-valued": false,
            "multi-valued-in-root": false,
            "type": "java.lang.String",
            "projection-type": "java.lang.String",
            "argument-type": "java.lang.String",
            "searchable": true,
            "sortable": false,
            "projectable": false,
            "aggregable": false
        },
        "name": {
            "multi-valued": false,
            "multi-valued-in-root": false,
            "type": "java.lang.String",
            "projection-type": "java.lang.String",
            "argument-type": "java.lang.String",
            "searchable": true,
            "sortable": false,
            "projectable": false,
            "aggregable": false,
            "analyzer": "standard"
        }
    }
}]

GET /rest/v2/caches/{cacheName}/search/stats

{
  "query": {
    "indexed_local": {
      "count": 1,
      "average": 12344.2,
      "max": 122324,
      "slowest": "FROM Entity WHERE field > 4"
    },
    "indexed_distributed": {
      "count": 0,
      "average": 0.0,
      "max": -1,
      "slowest": "FROM Entity WHERE field > 4"
    },
    "hybrid": {
      "count": 0,
      "average": 0.0,
      "max": -1,
      "slowest": "FROM Entity WHERE field > 4 AND desc = 'value'"
    },
    "non_indexed": {
      "count": 0,
      "average": 0.0,
      "max": -1,
      "slowest": "FROM Entity WHERE desc = 'value'"
    },
    "entity_load": {
      "count": 123,
      "average": 10.0,
      "max": 120
    }
  },
  "index": {
    "types": {
      "org.infinispan.same.test.Entity": {
        "count": 5660001,
        "size": 0
      },
      "org.infinispan.same.test.AnotherEntity": {
        "count": 40,
        "size": 345560
      }
    },
    "reindexing": false
  }
}

POST /rest/v2/caches/{cacheName}/search/stats?action=clear

GET /rest/v2/caches/{cacheName}/search/indexes/stats

{
    "indexed_class_names": ["org.infinispan.sample.User"],
    "indexed_entities_count": {
        "org.infinispan.sample.User": 4
    },
    "index_sizes": {
        "cacheName_protobuf": 14551
    },
    "reindexing": false
}

GET /rest/v2/caches/{cacheName}/search/query/stats

{
    "search_query_execution_count":20,
    "search_query_total_time":5,
    "search_query_execution_max_time":154,
    "search_query_execution_avg_time":2,
    "object_loading_total_time":1,
    "object_loading_execution_max_time":1,
    "object_loading_execution_avg_time":1,
    "objects_loaded_count":20,
    "search_query_execution_max_time_query_string": "FROM entity"
}

POST /rest/v2/caches/{cacheName}/search/query/stats?action=clear

Data Grid REST API を使用して、クロスサイトレプリケーション操作を行います。

GET /rest/v2/caches/{cacheName}/x-site/backups/

{
  "NYC": {
    "status": "online"
  },
  "LON": {
    "status": "mixed",
    "online": [
      "NodeA"
    ],
    "offline": [
      "NodeB"
    ]
  }
}

GET /rest/v2/caches/{cacheName}/x-site/backups/{siteName}

{
  "NodeA":"offline",
  "NodeB":"online"
}

POST /rest/v2/caches/{cacheName}/x-site/backups/{siteName}?action=take-offline

POST /rest/v2/caches/{cacheName}/x-site/backups/{siteName}?action=bring-online

POST /rest/v2/caches/{cacheName}/x-site/backups/{siteName}?action=start-push-state

POST /rest/v2/caches/{cacheName}/x-site/backups/{siteName}?action=cancel-push-state

GET /rest/v2/caches/{cacheName}/x-site/backups?action=push-state-status

{
   "NYC":"CANCELED",
   "LON":"OK"
}

POST /rest/v2/caches/{cacheName}/x-site/local?action=clear-push-state-status

POST /rest/v2/caches/{cacheName}/x-site/backups/{siteName}?action=cancel-receive-state

Data Grid クラスター間でキャッシュデータのローリングアップグレードを実行します

POST /rest/v2/caches/{cacheName}/rolling-upgrade/source-connection

{
  "remote-store": {
    "cache": "my-cache",
    "shared": true,
    "raw-values": true,
    "socket-timeout": 60000,
    "protocol-version": "2.9",
    "remote-server": [
      {
        "host": "127.0.0.2",
        "port": 12222
      }
    ],
    "connection-pool": {
      "max-active": 110,
      "exhausted-action": "CREATE_NEW"
    },
    "async-executor": {
      "properties": {
        "name": 4
      }
    },
    "security": {
      "authentication": {
        "server-name": "servername",
        "digest": {
          "username": "username",
          "password": "password",
          "realm": "realm",
          "sasl-mechanism": "DIGEST-MD5"
        }
      },
      "encryption": {
        "protocol": "TLSv1.2",
        "sni-hostname": "snihostname",
        "keystore": {
          "filename": "/path/to/keystore_client.jks",
          "password": "secret",
          "certificate-password": "secret",
          "key-alias": "hotrod",
          "type": "JKS"
        },
        "truststore": {
          "filename": "/path/to/gca.jks",
          "password": "secret",
          "type": "JKS"
        }
      }
    }
  }
}

GET /rest/v2/caches/{cacheName}/rolling-upgrade/source-connection

HEAD /rest/v2/caches/{cacheName}/rolling-upgrade/source-connection

POST /rest/v2/caches/{cacheName}?action=sync-data

DELETE /rest/v2/caches/{cacheName}/rolling-upgrade/source-connection

ペイロードに設定が含まれる POST リクエストでカウンターを作成します。

POST /rest/v2/counters/{counterName}

{
    "weak-counter":{
        "initial-value":5,
        "storage":"PERSISTENT",
        "concurrency-level":1
    }
}

{
    "strong-counter":{
        "initial-value":3,
        "storage":"PERSISTENT",
        "upper-bound":5
    }
}

DELETE リクエストで特定のカウンターを削除します。

DELETE /rest/v2/counters/{counterName}

GET リクエストで特定のカウンターの設定を取得します。

GET /rest/v2/counters/{counterName}/config

Data Grid は、JSON 形式でカウンターの設定で応答します。

GET リクエストでカウンターの値を取得します。

GET /rest/v2/counters/{counterName}

POST リクエストと ?action=reset パラメーターを使用せずに、カウンターの初期値を復元することができます。

POST /rest/v2/counters/{counterName}?action=reset

操作が正常に完了すると、サービスは 204 (No Content) を返します。

POST リクエストに ?action=increment パラメーターを指定して、カウンターの値を増加させます。

POST /rest/v2/counters/{counterName}?action=increment

?action=add および delta パラメーターを含む POST リクエストで、カウンターに任意の値を追加します。

POST /rest/v2/counters/{counterName}?action=add&delta={delta}

カウンターの値を減少させるには、POST リクエストと ?action=decrement パラメーターを使用します。

POST /rest/v2/counters/{counterName}?action=decrement

POST リクエストと getAndSet パラメーターを使用して、強力なカウンターの値をアトミックに設定します。

POST /rest/v2/counters/{counterName}?action=getAndSet&value={value}

操作が成功すると、Data Grid はペイロードの前の値を返します。

GET リクエストと compareAndSet パラメーターを使用して、強力なカウンターの値をアトミックに設定します。

POST /rest/v2/counters/{counterName}?action=compareAndSet&expect={expect}&update={update}

Data Grid は、現在の値が {expect} の場合、{update} にアトミックに値を設定します。操作が成功した場合、Data Grid は true.

GET リクエストと compareAndSwap パラメーターで強力なカウンターの値をアトミックに設定します。

POST /rest/v2/counters/{counterName}?action=compareAndSwap&expect={expect}&update={update}

Data Grid は、現在の値が {expect} の場合、{update} にアトミックに値を設定します。操作が成功すると、Data Grid はペイロードの前の値を返します。

GET リクエストで Data Grid クラスターのカウンターのリストを取得します。

GET /rest/v2/counters/

ペイロードに protobuf ファイルのコンテンツを含む POST リクエストで、Data Grid クラスター全体に Protobuf スキーマを作成します。

POST /rest/v2/schemas/{schemaName}

スキーマがすでに存在する場合、Data Grid は HTTP409 (Conflict) を返します。構文エラーのため、またはその依存関係の一部が欠落しているためにスキーマが有効でない場合、Data Grid はスキーマを格納し、応答本文にエラーを返します。

Data Grid は、スキーマ名とエラーで応答します。

{
  "name" : "users.proto",
  "error" : {
    "message": "Schema users.proto has errors",
    "cause": "java.lang.IllegalStateException:Syntax error in error.proto at 3:8: unexpected label: messoge"
  }
}

操作が正常に完了すると、サービスは 201 (Created) を返します。

GET リクエストで Data Grid から Protobuf スキーマを取得します。

GET /rest/v2/schemas/{schemaName}

ペイロードに protobuf ファイルのコンテンツを含む PUT リクエストで Protobuf スキーマを変更する。

PUT /rest/v2/schemas/{schemaName}

構文エラーのため、またはその依存関係の一部が欠落しているためにスキーマが有効でない場合、Data Grid はスキーマを更新し、応答本文にエラーを返します。

{
  "name" : "users.proto",
  "error" : {
    "message": "Schema users.proto has errors",
    "cause": "java.lang.IllegalStateException:Syntax error in error.proto at 3:8: unexpected label: messoge"
  }
}

DELETE リクエストで Data Grid クラスターから Protobuf スキーマを削除します。

DELETE /rest/v2/schemas/{schemaName}

操作が正常に完了すると、サービスは 204 (No Content) を返します。

GET リクエストで利用可能なすべての Protobuf スキーマをリストアップします。

GET /rest/v2/schemas/

Data Grid は、クラスターで使用可能なすべてのスキーマのリストで応答します。

[ {
  "name" : "users.proto",
  "error" : {
    "message": "Schema users.proto has errors",
    "cause": "java.lang.IllegalStateException:Syntax error in error.proto at 3:8: unexpected label: messoge"
  }
}, {
  "name" : "people.proto",
  "error" : null
}]

GET 要求で使用可能なすべての Protobuf タイプを一覧表示します。

GET /rest/v2/schemas?action=types

Data Grid は、クラスターで使用可能なすべてのタイプのリストで応答します。

["org.infinispan.Person", "org.infinispan.Phone"]

GET リクエストを使用して、キャッシュマネージャーに関する情報を取得します。

GET /rest/v2/container

Data Grid は、次の例のように、JSON 形式の情報で応答します。

{
    "version":"xx.x.x-FINAL",
    "name":"default",
    "coordinator":true,
    "cache_configuration_names":[
        "___protobuf_metadata",
        "cache2",
        "CacheManagerResourceTest",
        "cache1"
    ],
    "cluster_name":"ISPN",
    "physical_addresses":"[127.0.0.1:35770]",
    "coordinator_address":"CacheManagerResourceTest-NodeA-49696",
    "cache_manager_status":"RUNNING",
    "created_cache_count":"3",
    "running_cache_count":"3",
    "node_address":"CacheManagerResourceTest-NodeA-49696",
    "cluster_members":[
        "CacheManagerResourceTest-NodeA-49696",
        "CacheManagerResourceTest-NodeB-28120"
    ],
    "cluster_members_physical_addresses":[
        "127.0.0.1:35770",
        "127.0.0.1:60031"
    ],
    "cluster_size":2,
    "defined_caches":[
        {
            "name":"CacheManagerResourceTest",
            "started":true
        },
        {
            "name":"cache1",
            "started":true
        },
        {
            "name":"___protobuf_metadata",
            "started":true
        },
        {
            "name":"cache2",
            "started":true
        }
    ],
    "local_site": "LON",
    "relay_node": true,
    "relay_nodes_address": [
      "CacheManagerResourceTest-NodeA-49696"
    ],
    "sites_view": [
        "LON",
        "NYC"
    ],
    "rebalancing_enabled": true
}

GET リクエストを使用して Data Grid クラスターのヘルス情報を取得します。

GET /rest/v2/container/health

Data Grid は、次の例のように、JSON 形式のクラスターヘルス情報で応答します。

{
    "cluster_health":{
        "cluster_name":"ISPN",
        "health_status":"HEALTHY",
        "number_of_nodes":2,
        "node_names":[
            "NodeA-36229",
            "NodeB-28703"
        ]
    },
    "cache_health":[
        {
            "status":"HEALTHY",
            "cache_name":"___protobuf_metadata"
        },
        {
            "status":"HEALTHY",
            "cache_name":"cache2"
        },
        {
            "status":"HEALTHY",
            "cache_name":"mycache"
        },
        {
            "status":"HEALTHY",
            "cache_name":"cache1"
        }
    ]
}

認証を必要としない GET リクエストを使用して、Data Grid コンテナーの健全性ステータスを取得します。

GET /rest/v2/container/health/status

Data Grid は以下のいずれかを text/plain 形式で応答します。

HEAD リクエストを使用して Data Grid サーバーの REST エンドポイントの可用性を確認します。

HEAD /rest/v2/container/health

正常な応答コードを受信した場合、Data Grid REST サーバーが実行され、要求を処理しています。

、GET リクエストを使用して、データコンテナーのグローバル設定を取得します。

GET /rest/v2/container/config

GET リクエストを使用してすべてのキャッシュの設定を取得します。

GET /rest/v2/container/cache-configs

Data Grid は、以下の例のように、各キャッシュとキャッシュ設定を含む JSON 配列で応答します。

[
  {
      "name":"cache1",
      "configuration":{
          "distributed-cache":{
              "mode":"SYNC",
              "partition-handling":{
                  "when-split":"DENY_READ_WRITES"
              },
              "statistics":true
          }
      }
  },
  {
      "name":"cache2",
      "configuration":{
          "distributed-cache":{
              "mode":"SYNC",
              "transaction":{
                  "mode":"NONE"
              }
          }
      }
  }
]

GET リクエストで、利用可能なすべての Data Grid キャッシュテンプレートを取得します。

GET /rest/v2/cache-configs/templates

GET リクエストを使用して、コンテナーの統計情報を取得します。

GET /rest/v2/container/stats

Data Grid は、次の例のように、JSON 形式のキャッシュマネージャー統計で応答します。

{
    "statistics_enabled":true,
    "read_write_ratio":0.0,
    "time_since_start":1,
    "time_since_reset":1,
    "number_of_entries":0,
    "off_heap_memory_used":0,
    "data_memory_used":0,
    "misses":0,
    "remove_hits":0,
    "remove_misses":0,
    "evictions":0,
    "average_read_time":0,
    "average_read_time_nanos":0,
    "average_write_time":0,
    "average_write_time_nanos":0,
    "average_remove_time":0,
    "average_remove_time_nanos":0,
    "required_minimum_number_of_nodes":1,
    "hits":0,
    "stores":0,
    "current_number_of_entries_in_memory":0,
    "hit_ratio":0.0,
    "retrievals":0
}

POST リクエストで統計情報をリセットします。

POST /rest/v2/container/stats?action=reset

POST リクエストを使用して、サーバー上の Data Grid コンテナーをシャットダウンします。

POST /rest/v2/container?action=shutdown

Data Grid は 204 (No Content) と応答し、コンテナー内のすべてのキャッシュをシャットダウンします。サーバーはアクティブなエンドポイントとクラスタリングで実行されたままですが、コンテナーリソースへの REST 呼び出しは、503 Service Unavailable 応答になります。

すべてのキャッシュの自動リバランスをオンにします。

POST /rest/v2/container?action=enable-rebalancing

すべてのキャッシュの自動リバランスをオフにします。

POST /rest/v2/container?action=disable-rebalancing

現在 Data Grid に保存されているリソース (キャッシュ、キャッシュテンプレート、カウンター、Protobuf スキーマ、サーバータスクなど) を含むバックアップアーカイブ application/zip を作成します。

POST /rest/v2/container/backups/{backupName}

同じ名前のバックアップがすでに存在する場合、サービスは 409 (Conflict) 応答します。directory パラメーターが無効な場合、サービスは 400 (Bad Request) 返します。202 応答は、バックアップ要求が処理のために受け入れられたことを示します。

オプションで、次のように、バックアップ操作のパラメーターを含む JSON ペイロードをリクエストに含めます。

次の例では、指定されたディレクトリーに [cache1,cache2] という名前のすべてのカウンターとキャッシュを含むバックアップアーカイブを作成します。

{
  "directory": "/path/accessible/to/the/server",
  "resources": {
    "caches": ["cache1", "cache2"],
    "counters": ["*"]
  }
}

進行中、完了、または失敗したすべてのバックアップ操作の名前を取得します。

GET /rest/v2/container/backups

Data Grid は、以下の例のように、すべてのバックアップ名の配列で応答します。

["backup1", "backup2"]

バックアップ操作が完了していることを確認します。

HEAD /rest/v2/container/backups/{backupName}

200 のレスポンスは、バックアップアーカイブが利用可能であることを示します。202 の応答は、バックアップ操作が進行中であることを示します。

サーバーからバックアップアーカイブをダウンロードします。

GET /rest/v2/container/backups/{backupName}

200 のレスポンスは、バックアップアーカイブが利用可能であることを示します。202 の応答は、バックアップ操作が進行中であることを示します。

サーバーからバックアップアーカイブを削除します。

DELETE /rest/v2/container/backups/{backupName}

204 応答は、バックアップアーカイブが削除されたことを示します。202 応答は、バックアップ操作が進行中であるが、操作が完了すると削除されることを示します。

バックアップアーカイブから Data Grid リソースを復元します。提供されている {restoreName} は、復元の進行状況を追跡するためのものであり、復元されるバックアップファイルの名前とは無関係です。

POST /rest/v2/container/restores/{restoreName}

202 応答は、復元要求が処理のために受け入れられたことを示します。

{
  "location": "/path/accessible/to/the/server/backup-to-restore.zip",
  "resources": {
    "counters": ["*"]
  }
}

Content-Type: multipart/form-data; boundary=5ec9bc07-f069-4662-a535-46069afeda32
Content-Length: 7721

--5ec9bc07-f069-4662-a535-46069afeda32
Content-Disposition: form-data; name="resources"
Content-Length: 23

{"scripts":["test.js"]}
--5ec9bc07-f069-4662-a535-46069afeda32
Content-Disposition: form-data; name="backup"; filename="testManagerRestoreParameters.zip"
Content-Type: application/zip
Content-Length: 7353

<zip-bytes>
--5ec9bc07-f069-4662-a535-46069afeda32--

進行中、完了、または失敗したすべての復元要求の名前を取得します。

GET /rest/v2/container/restores

Data Grid は、次の例のように、すべての復元名の配列で応答します。

["restore1", "restore2"]

復元操作が完了したことを確認します。

HEAD /rest/v2/container/restores/{restoreName}

201 (Created) 応答は、リストア操作が完了したことを示します。202 (Accepted) 応答は、バックアップ操作が進行中であることを示します。

サーバーから復元要求のメタデータを削除します。このアクションにより、復元要求に関連付けられているすべてのメタデータが削除されますが、復元されたコンテンツは削除されません。リクエストのメタデータを削除すると、リクエスト名を使用して後続の復元操作を実行できます。

DELETE /rest/v2/container/restores/{restoreName}

204 (No Content) 応答は、復元メタデータが削除されたことを示します。202 (Accepted) 応答は、復元操作が進行中であり、操作が完了すると削除されることを示します。

Server-Sent Events を使用して、設定変更に関するイベントを受信します。event 値は、create-cache、remove-cache、update-cache、create-template、remove-template、または update- template のいずれかになります。data 値には、作成されたエンティティーの宣言型設定が含まれます。削除イベントには、削除されたエンティティーの名前のみが含まれます。

GET /rest/v2/container/config?action=listen

Server-Sent Events を使用してコンテナーからイベントを受け取ります。発行されたイベントはログに記録された情報に基づいているため、各イベントにはメッセージに関連付けられた識別子が含まれています。event 値は lifecycle-event になります。data には、message、category、level、timestamp、owner、context、および scope を含む、ログに記録された情報があり、その一部は空である可能性があります。現在、LIFECYCLE イベントのみを公開しています。

GET /rest/v2/container?action=listen

Cache Managers でクロスサイト操作を行うと、すべてのキャッシュに操作が適用されます。

GET /rest/v2/container/x-site/backups/

{
   "SFO-3":{
      "status":"online"
   },
   "NYC-2":{
      "status":"mixed",
      "online":[
         "CACHE_1"
      ],
      "offline":[
         "CACHE_2"
      ],
      "mixed": [
         "CACHE_3"
      ]
   }
}

GET /rest/v2/container/x-site/backups/{site}

POST /rest/v2/container/x-site/backups/{siteName}?action=take-offline

POST /rest/v2/container/x-site/backups/{siteName}?action=bring-online

GET /rest/v2/caches/{cacheName}/x-site/backups/{site}/state-transfer-mode

POST /rest/v2/caches/{cacheName}/x-site/backups/{site}/state-transfer-mode?action=set&mode={mode}

POST /rest/v2/container/x-site/backups/{siteName}?action=start-push-state

POST /rest/v2/container/x-site/backups/{siteName}?action=cancel-push-state

GET リクエストを使用して Data Grid サーバーに関する基本情報を表示します。

GET /rest/v2/server

Data Grid は、次の例のように、サーバー名、コードネーム、およびバージョンを JSON 形式で応答します。

{
  "version":"Infinispan 'Codename' xx.x.x.Final"
}

GET リクエストで Data Grid サーバーの Cache Manager のリストを取得します。

GET /rest/v2/server/cache-managers

Data Grid は、サーバー用に設定された Cache Manager 名の配列で応答します。

特定のキャッシュをクライアントの要求から一時的に除外するように Data Grid を設定します。Cache Manager 名とキャッシュの名前を含む POST リクエストを送信します。

POST /rest/v2/server/ignored-caches/{cache}

Data Grid は、キャッシュが無視リストに正常に追加された場合は 204 (No Content)、キャッシュや Cache Manager が見つからない場合は 404 (Not Found) で応答します。

DELETE リクエストでキャッシュを無視リストから削除します。

DELETE /rest/v2/server/ignored-caches/{cache}

Data Grid は、キャッシュが無視リストから正常に削除された場合は 204 (No Content)、キャッシュや Cache Manager が見つからない場合は 404 (Not Found) で応答します。

GET リクエストでキャッシュが無視されることを確認します。

GET /rest/v2/server/ignored-caches/

GET リクエストで Data Grid サーバーの設定を取得します。

GET /rest/v2/server/config

Data Grid は、以下のように JSON 形式で設定を応答します。

{
    "server":{
        "interfaces":{
            "interface":{
                "name":"public",
                "inet-address":{
                    "value":"127.0.0.1"
                }
            }
        },
        "socket-bindings":{
            "port-offset":0,
            "default-interface":"public",
            "socket-binding":[
                {
                    "name":"memcached",
                    "port":11221,
                    "interface":"memcached"
                }
            ]
        },
        "security":{
            "security-realms":{
                "security-realm":{
                    "name":"default"
                }
            }
        },
        "endpoints":{
            "socket-binding":"default",
            "security-realm":"default",
            "hotrod-connector":{
                "name":"hotrod"
            },
            "rest-connector":{
                "name":"rest"
            }
        }
    }
}

GET リクエストで Data Grid サーバーのすべての環境変数を取得します。

GET /rest/v2/server/env

GET リクエストで Data Grid サーバーの JVM メモリー使用量情報を取得します。

GET /rest/v2/server/memory

Data Grid は、ヒープと非ヒープのメモリー統計、直接のメモリー使用量、メモリープールとガベージコレクションに関する情報を JSON 形式で応答します。

POST 要求で Data Grid サーバーの JVM ヒープダンプを生成します。

POST /rest/v2/server/memory?action=heap-dump[&live=true|false]

Data Grid は、サーバーのデータディレクトリーに HPROF 形式のヒープダンプファイルを生成し、JSON 形式のファイルのフルパスで応答します。

GET リクエストで、JVM の現在のスレッドダンプを取得します。

GET /rest/v2/server/threads

Data Grid は現在のスレッドダンプを text/plain 形式で応答します。

GET リクエストで Data Grid サーバーの集約されたレポートを取得します。要求されたサーバーのレポートを取得するには、以下を実行します。

GET /rest/v2/server/report

クラスター内の別のサーバーのレポートを取得するには、ノードを名前で参照します。

GET /rest/v2/server/report/{nodeName}

Data Grid は、Data Grid サーバーとホストの両方に関する診断情報を含む集約されたレポートを含む tar.gz アーカイブで応答します。レポートは、設定ファイルやログファイルに加えて、CPU、メモリー、オープンファイル、ネットワークソケットとルーティング、スレッドに関する詳細を提供します。

POST リクエストで Data Grid サーバーを停止する。

POST /rest/v2/server?action=stop

Data Grid は 204 (No Content) と応答し、実行を停止します。

GET リクエストを使用して、Data Grid Server に接続されたクライアントに関する情報をリスト表示します。

GET /rest/v2/server/connections

Data Grid は、次の例のように、すべてのアクティブなクライアント接続に関する詳細を JSON 形式で応答します。

[
  {
    "id": 2,
    "name": "flower",
    "created": "2023-05-18T14:54:37.882566188Z",
    "principal": "admin",
    "local-address": "/127.0.0.1:11222",
    "remote-address": "/127.0.0.1:58230",
    "protocol-version": "RESP3",
    "client-library": null,
    "client-version": null,
    "ssl-application-protocol": "http/1.1",
    "ssl-cipher-suite": "TLS_AES_256_GCM_SHA384",
    "ssl-protocol": "TLSv1.3"
  },
  {
    "id": 0,
    "name": null,
    "created": "2023-05-18T14:54:07.727775875Z",
    "principal": "admin",
    "local-address": "/127.0.0.1:11222",
    "remote-address": "/127.0.0.1:35716",
    "protocol-version": "HTTP/1.1",
    "client-library": "Infinispan CLI 15.0.0-SNAPSHOT",
    "client-version": null,
    "ssl-application-protocol": "http/1.1",
    "ssl-cipher-suite": "TLS_AES_256_GCM_SHA384",
    "ssl-protocol": "TLSv1.3"
  }
]

GET リクエストを使用して、キャッシュ設定のデフォルト値を取得します。

POST /rest/v2/server/caches/defaults

Data Grid は、キャッシュ設定のデフォルト値を JSON 形式で応答します。

POST 要求を使用して Data Grid クラスター全体をシャットダウンします。

POST /rest/v2/cluster?action=stop

Data Grid は 204 (No Content) と応答し、クラスター全体の秩序あるシャットダウンを実行します。

GET リクエストに ?action=stop&server パラメーターを指定して、Data Grid クラスター内の 1 つまたは複数の特定のサーバーをシャットダウンすることができます。

POST /rest/v2/cluster?action=stop&server={server1_host}&server={server2_host}

Data Grid は 204 (No Content) と応答します。

クラスターのキャッシュコンテナーに現在保存されているリソース (キャッシュ、テンプレート、カウンター、Protobuf スキーマ、サーバータスクなど) を含むバックアップアーカイブ、application/zip を作成します。

POST /rest/v2/cluster/backups/{backupName}

オプションで、次のように、バックアップ操作のパラメーターを含む JSON ペイロードをリクエストに含めます。

バックアップ操作が正常に完了すると、サービスは 202 (Accepted) を返します。同じ名前のバックアップがすでに存在する場合、サービスは 409 (Conflict) 返します。directory パラメーターが無効な場合、サービスは 400 (Bad Request) 返します。

進行中、完了、または失敗したすべてのバックアップ操作の名前を取得します。

GET /rest/v2/cluster/backups

Data Grid は、以下の例のように、すべてのバックアップ名の配列で応答します。

["backup1", "backup2"]

バックアップ操作が完了していることを確認します。200 のレスポンスは、バックアップアーカイブが利用可能であることを示します。202 の応答は、バックアップ操作が進行中であることを示します。

HEAD /rest/v2/cluster/backups/{backupName}

サーバーからバックアップアーカイブをダウンロードします。200 のレスポンスは、バックアップアーカイブが利用可能であることを示します。202 の応答は、バックアップ操作が進行中であることを示します。

GET /rest/v2/cluster/backups/{backupName}

サーバーからバックアップアーカイブを削除します。204 応答は、バックアップアーカイブが削除されたことを示します。202 応答は、バックアップ操作が進行中であるが、操作が完了すると削除されることを示します。

DELETE /rest/v2/cluster/backups/{backupName}

バックアップアーカイブ内のリソースを適用して、Data Grid クラスターを復元します。提供されている {restoreName} は、復元の進行状況を追跡するためのものであり、復元されるバックアップファイルの名前とは無関係です。

POST /rest/v2/cluster/restores/{restoreName}

202 応答は、復元要求が処理のために受け入れられたことを示します。

{
  "location": "/path/accessible/to/the/server/backup-to-restore.zip",
  "resources": {
    "counters": ["*"]
  }
}

Content-Type: multipart/form-data; boundary=5ec9bc07-f069-4662-a535-46069afeda32
Content-Length: 7798

--5ec9bc07-f069-4662-a535-46069afeda32
Content-Disposition: form-data; name="backup"; filename="testManagerRestoreParameters.zip"
Content-Type: application/zip
Content-Length: 7353

<zip-bytes>
--5ec9bc07-f069-4662-a535-46069afeda32--

進行中、完了、または失敗したすべての復元要求の名前を取得します。

GET /rest/v2/cluster/restores

Data Grid は、次の例のように、すべての復元名の配列で応答します。

["restore1", "restore2"]

復元操作が完了したことを確認します。

HEAD /rest/v2/cluster/restores/{restoreName}

201 (Created) 応答は、リストア操作が完了したことを示します。202 の応答は、バックアップ操作が進行中であることを示します。

サーバーから復元要求のメタデータを削除します。このアクションにより、復元要求に関連付けられているすべてのメタデータが削除されますが、復元されたコンテンツは削除されません。リクエストのメタデータを削除すると、リクエスト名を使用して後続の復元操作を実行できます。

DELETE /rest/v2/cluster/restores/{restoreName}

204 応答は、復元メタデータが削除されたことを示します。202 応答は、復元操作が進行中であり、操作が完了すると削除されることを示します。

Data Grid クラスター内のすべてのサーバーに関するディストリビューションの詳細を取得します。

GET /rest/v2/cluster?action=distribution

クラスター内の各 Data Grid サーバー統計の JSON 配列を次の形式で返します。

[
  {
    "node_name": "NodeA",
    "node_addresses": [
      "127.0.0.1:39313"
    ],
    "memory_available": 466180016,
    "memory_used": 56010832
  },
  {
    "node_name": "NodeB",
    "node_addresses": [
      "127.0.0.1:47477"
    ],
    "memory_available": 467548568,
    "memory_used": 54642280
  }
]

配列内の各要素は、Data Grid ノードを表します。統計収集が無効になっている場合、メモリー使用量の値に関する情報は -1 です。プロパティーは次のとおりです。

GET リクエストで設定されたすべてのアペンダーのリストを表示します。

GET /rest/v2/logging/appenders

Data Grid は、次の例のように、JSON 形式のアペンダーのリストで応答します。

{
  "STDOUT" : {
    "name" : "STDOUT"
  },
  "JSON-FILE" : {
    "name" : "JSON-FILE"
  },
  "HR-ACCESS-FILE" : {
    "name" : "HR-ACCESS-FILE"
  },
  "FILE" : {
    "name" : "FILE"
  },
  "REST-ACCESS-FILE" : {
    "name" : "REST-ACCESS-FILE"
  }
}

GET リクエストで設定されたすべてのロガーのリストを表示します。

GET /rest/v2/logging/loggers

Data Grid は、次の例のように、JSON 形式のロガーのリストで応答します。

[ {
  "name" : "",
  "level" : "INFO",
  "appenders" : [ "STDOUT", "FILE" ]
}, {
  "name" : "org.infinispan.HOTROD_ACCESS_LOG",
  "level" : "INFO",
  "appenders" : [ "HR-ACCESS-FILE" ]
}, {
  "name" : "com.arjuna",
  "level" : "WARN",
  "appenders" : [ ]
}, {
  "name" : "org.infinispan.REST_ACCESS_LOG",
  "level" : "INFO",
  "appenders" : [ "REST-ACCESS-FILE" ]
} ]

新しいロガーを作成するか、PUT リクエストで既存のロガーを変更します。

PUT /rest/v2/logging/loggers/{loggerName}?level={level}&appender={appender}&appender={appender}...

Data Grid は、{loggerName} で識別されるロガーのレベルを {level} に設定します。オプションで、ロガーに 1 つ以上のアペンダーを設定できます。アペンダーが指定されていない場合は、ルートロガーで指定されたアペンダーが使用されます。

操作が正常に完了すると、サービスは 204 (No Content) を返します。

DELETE リクエストで既存のロガーを削除します。

DELETE /rest/v2/logging/loggers/{loggerName}

Data Grid は、{loggerName} で識別されるロガーを削除し、root ロガー設定の使用に効果的に戻します。

操作が正常に処理された場合、サービスは応答コード 204 (No Content) を返します。

GET リクエストで利用可能なサーバータスクに関する情報を表示します。

GET /rest/v2/tasks

Data Grid は、利用可能なタスクのリストで応答します。リストには、次の例のように、タスクの名前、タスクを処理するエンジン、タスクの名前付きパラメーター、タスクの実行モード (ONE_NODE または ALL_NODES)、許可されるセキュリティーロールが JSON 形式で記載されています。

[
  {
    "name": "SimpleTask",
    "type": "TaskEngine",
    "parameters": [
      "p1",
      "p2"
    ],
    "execution_mode": "ONE_NODE",
    "allowed_role": null
  },
  {
    "name": "RunOnAllNodesTask",
    "type": "TaskEngine",
    "parameters": [
      "p1"
    ],
    "execution_mode": "ALL_NODES",
    "allowed_role": null
  },
  {
    "name": "SecurityAwareTask",
    "type": "TaskEngine",
    "parameters": [],
    "execution_mode": "ONE_NODE",
    "allowed_role": "MyRole"
  }
]

タスク名、オプションのキャッシュ名、param で始まる必須パラメーターを含む POST リクエストでタスクを実行します。

POST /rest/v2/tasks/SimpleTask?action=exec&cache=mycache&param.p1=v1&param.p2=v2

Data Grid はタスクの結果で応答します。

PUT または POST リクエストでスクリプトタスクをアップロードします。

リクエストのコンテンツペイロードとしてスクリプトを提供します。Data Grid がスクリプトをアップロードした後、GET リクエストでスクリプトを実行することができます。

POST /rest/v2/tasks/taskName

GET 要求でスクリプトタスクをダウンロードします。

GET /rest/v2/tasks/taskName?action=script

ユーザーのプリンシパルとアクセス制御リストに関する情報を表示します。

GET /rest/v2/security/user/acl

Data Grid は、リクエストを実行したユーザーに関する情報で応答します。このリストには、ユーザーのプリンシパル、リソースのリストとユーザーがアクセスする際のパーミッションが含まれています。

{
  "subject": [
    {
      "name": "deployer",
      "type": "NamePrincipal"
    }
  ],
  "global": [
    "READ", "WRITE", "EXEC", "LISTEN", "BULK_READ", "BULK_WRITE", "CREATE", "MONITOR", "ALL_READ", "ALL_WRITE"  ],
  "caches": {
    "___protobuf_metadata": [
      "READ", "WRITE", "EXEC", "LISTEN", "BULK_READ", "BULK_WRITE", "CREATE", "MONITOR", "ALL_READ", "ALL_WRITE"
    ],
    "mycache": [
      "LIFECYCLE", "READ", "WRITE", "EXEC", "LISTEN", "BULK_READ", "BULK_WRITE", "ADMIN", "CREATE", "MONITOR", "ALL_READ", "ALL_WRITE"
    ],
    "___script_cache": [
      "READ", "WRITE", "EXEC", "LISTEN", "BULK_READ", "BULK_WRITE", "CREATE", "MONITOR", "ALL_READ", "ALL_WRITE"
    ]
  }
}

クラスター全体のセキュリティーキャッシュをフラッシュします。

POST /rest/v2/security/cache?action=flush

サーバーに定義されている利用可能なすべてのロールを表示します。

GET /rest/v2/security/roles

Data Grid は、利用可能なロールのリストで応答します。認証が有効な場合、ADMIN 権限を持つユーザーのみがこの API を呼び出すことができます。

["observer","application","admin","monitor","deployer"]

サーバーで定義されている利用可能なすべてのロールを詳細とともに表示します。

GET /rest/v2/security/roles?action=detailed

Data Grid は、使用可能なロールとその詳細のリストで応答します。認証が有効な場合、ADMIN 権限を持つユーザーのみがこの API を呼び出すことができます。

{
  "observer": {
    "inheritable": true,
    "permissions": [
      "MONITOR",
      "ALL_READ"
    ],
    "implicit": true,
    "description": "..."
  },
  "application": {
    "inheritable": true,
    "permissions": [
      "MONITOR",
      "ALL_WRITE",
      "EXEC",
      "LISTEN",
      "ALL_READ"
    ],
    "implicit": true,
    "description": "..."
  },
  "admin": {
    "inheritable": true,
    "permissions": [
      "ALL"
    ],
    "implicit": true,
    "description": "..."
  },
  "monitor": {
    "inheritable": true,
    "permissions": [
      "MONITOR"
    ],
    "implicit": true,
    "description": "..."
  },
  "deployer": {
    "inheritable": true,
    "permissions": [
      "CREATE",
      "MONITOR",
      "ALL_WRITE",
      "EXEC",
      "LISTEN",
      "ALL_READ"
    ],
    "implicit": true,
    "description": "..."
  }
}

プリンシパルにマップするすべてのロールを表示します。

GET /rest/v2/security/roles/some_principal

Data Grid は、指定されたプリンシパルで使用可能なロールのリストで応答します。プリンシパルは、使用中の領域に存在する必要はありません。

["observer"]

プリンシパルに 1 つ以上の新しいロールを付与します。

PUT /rest/v2/security/roles/some_principal?action=grant&role=role1&role=role2

以前にプリンシパルに付与された 1 つ以上のロールを削除します。

PUT /rest/v2/security/roles/some_principal?action=deny&role=role1&role=role2

ユーザーを列挙できるすべてのセキュリティーレルムのプリンシパル名をリスト表示します (properties、ldap)

GET /rest/v2/security/principals

Data Grid は各レルムにキーが付けられたプリンシパルのリストで応答します。

{"default:properties":["admin","user1","user2"]}

リクエスト本文に名前、権限、およびオプションの説明を定義して、ロールを作成します。

POST /rest/v2/security/permissions/somerole?permission=permission1&permission=permission2

既存のロール権限や説明を更新します。

POST /rest/v2/security/permissions/somerole?permission=permission1&permission=permission2

既存のロールを削除します。

DELETE /rest/v2/security/permissions/somerole

ロールのすべての権限を表示します。

GET /rest/v2/security/permissions/somerole

Data Grid は、指定されたプリンシパルで使用可能なロールのリストで応答します。プリンシパルは、使用中の領域に存在する必要はありません。

{
  "name" : "application",
  "permissions" : [ "LISTEN","ALL_READ","MONITOR","ALL_WRITE","EXEC" ],
  "inheritable": true,
  "implicit": true,
  "description": "..."
}

Data Grid サーバーと REST API の間でトレース伝播を有効にする場合は、クライアント側とサーバー側の両方でトレースを設定する必要があります。

OpenTelemetry トレーススパンを Data Grid スパンに伝播するには、REST 呼び出しごとにトレースコンテキストを設定する必要があります。

クライアントアプリケーションが生成するトレーススパンは、Data Grid サーバーによって生成される依存スパンと関連付けられます。