您可以根据不同格式写入和读取数据，在需要时可以在这些格式之间转换数据。

以下"标准"格式是可交换的：

您还可以将前面的数据格式转换为以下格式：

通过 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 会尝试下一个 文本/纯文本格式（以秒 为 0.7））。最后，Data Grid 会退回到是是的，它根据缓存配置选择合适的格式。

创建任何 REST 资源都需要一个作为 URL 一部分的名称，如果此名称包含 RFC 3986 spec 第 2.2 节 中定义的特殊字符，则需要使用 Percent 的编码 机制对其进行编码。

大多数 REST API 调用中都包含在 URL 中的 Key。Data Grid 在处理这些调用时假设 Key 是 java.lang.String，但您可以使用特定的标头 Key-Content-Type 作为不同的格式的键。

API 调用：

`PUT /my-cache/AQIDBDM=`

headers:

key-Content-Type: application/octet-stream

API 调用：

GET /my-cache/0x01CA03042F

headers:

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

API 调用：

POST /my-cache/3.141456

headers:

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

application/x-java-object 的 type 参数仅限于：

当缓存被索引时，或者配置为存储 application/x-protostream 时，您可以发送和接收自动从 Protobuf 转换的 JSON 文档。

您必须注册 Protobuf 模式，才能进行转换。

要通过 REST 注册 protobuf 模式，请在 protobufprotobuf_metadata 缓存中调用 POST 或 PUT，如下例所示：

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

在编写 JSON 文档时，文档中必须存在一个特殊字段 _type，以标识与文档对应的 Protobuf 消息。

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

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

在启动服务器时，可以使用 VM 属性 infinispan.server.rest.cors-allow，以允许对一个或多个来源的所有权限。例如：

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

使用此方法指定的所有原始卷优先于配置的规则。

使用 POST 请求在有效负载中包含 XML 或 JSON 配置，在 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"/>
  </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"
      }
    },
    "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"
  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"/>
  </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"
      }
    },
    "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"
  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:13.0 https://infinispan.org/schemas/infinispan-config-13.0.xsd
                          urn:infinispan:server:13.0 https://infinispan.org/schemas/infinispan-server-13.0.xsd"
      xmlns="urn:infinispan:config:13.0"
      xmlns:server="urn:infinispan:server:13.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:
  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"

{
  "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"
            }
          }
        }
      }
    }
  }
}

通过 PUT 请求（在有效负载中包含 XML 或 JSON 配置）在 Data Grid 集群中对缓存配置进行更改。

PUT /rest/v2/caches/{cacheName}

检查带有 HEAD 请求的 Data Grid 集群中是否有缓存。

HEAD /rest/v2/caches/{cacheName}

使用 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 标头和所需的输出格式指定配置的输入格式。例如，以下命令将复制的缓存配置从 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>'

调用 GET 请求，以检索 Data Grid 缓存的所有详细信息。

GET /rest/v2/caches/{name}

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,
    "total_number_of_entries": -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
}

调用 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 请求，以更改 mutable 缓存配置属性。

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

使用 POST 请求向缓存添加条目。

POST /rest/v2/caches/{cacheName}/{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}

使用 DELETE 请求从 Data Grid 集群中删除缓存。

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
    }
]

要从缓存中删除所有数据，请使用 ?action=clear 参数调用 POST 请求。

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/

使用 服务器层事件接收缓存事件。事件 值将是 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}

使用 GET 请求和任何 HTTP 客户端中的 ?action=search&query 参数查询远程缓存。

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

{
  "total_results" : 150,
  "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  /v2/caches/{cacheName}/search/indexes?action=mass-index

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

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

通过 GET 请求和 compareAndSet 参数，以原子方式设置计数器的值。

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

如果当前值为 {expect}，则数据网格会以原子方式将值设置为 {update}。如果操作成功，Data Grid 将返回 true。

通过 GET 请求和 compareAndSwap 参数，以原子方式设置计数器的值。

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

如果当前值为 {expect}，则数据网格会以原子方式将值设置为 {update}。如果操作成功，Data Grid 会从载荷返回先前的值。

使用 GET 请求检索 Data Grid 集群中的计数器列表。

GET /rest/v2/counters/

使用 POST 请求在 Data Grid 集群中创建 Protobuf 模式，该请求在有效负载中包含 protobuf 文件的内容。

POST /rest/v2/schemas/{schemaName}

如果架构已存在，Data Grid 会返回 HTTP 409 (Conflict)。如果架构无效，要么因为语法错误，或者由于缺少其某些依赖项，Data Grid 存储架构并在响应正文中返回错误。

Data Grid 使用 schema 名称和任何错误做出响应。

{
  "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}

使用 PUT 请求修改 Protobuf 模式，该模式在有效负载中包含 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 请求检索有关缓存管理器的信息。

GET /rest/v2/cache-managers/{cacheManagerName}

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/cache-managers/{cacheManagerName}/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 请求检索缓存管理器的健康状况。

GET /rest/v2/cache-managers/{cacheManagerName}/health/status

Data Grid 使用 文本/plain 格式以下之一进行响应：

通过 HEAD 请求验证 Data Grid server REST 端点的可用性。

HEAD /rest/v2/cache-managers/{cacheManagerName}/health

如果您收到成功的响应代码，则 Data Grid REST 服务器正在运行并服务请求。

使用 GET 请求检索缓存管理器的全局配置。

GET /rest/v2/cache-managers/{cacheManagerName}/config

使用 GET 请求检索所有缓存的配置。

GET /rest/v2/cache-managers/{cacheManagerName}/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-managers/{cacheManagerName}/cache-configs/templates

检索缓存管理器的所有可用缓存列表，以及缓存状态和详细信息，以及 GET 请求。

GET /rest/v2/cache-managers/{cacheManagerName}/caches

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
}]

使用 GET 请求检索缓存管理器的统计信息。

GET /rest/v2/cache-managers/{cacheManagerName}/stats

Data Grid 以 JSON 格式响应 Cache Manager 统计信息，如下例所示：

{
    "statistics_enabled":true,
    "read_write_ratio":0.0,
    "time_since_start":1,
    "time_since_reset":1,
    "number_of_entries":0,
    "total_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 请求关闭服务器上的 Data Grid 容器。

POST /rest/v2/container?action=shutdown

Data Grid 使用 204 （无内容） 响应，然后关闭容器中的所有缓存。服务器保持使用活动端点和集群运行，但对容器资源的 REST 调用会导致 503 Service Unavailable 响应。

为所有缓存打开自动重新平衡。

POST /rest/v2/cache-managers/{cacheManagerName}?action=enable-rebalancing

为所有缓存关闭自动重新平衡。

POST /rest/v2/cache-managers/{cacheManagerName}?action=disable-rebalancing

创建备份存档 application/zip，其中包含当前存储在缓存管理器中的资源（缓存、缓存模板、计数器、Protobuf 模式、服务器任务等）。

POST /rest/v2/cache-managers/{cacheManagerName}/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/cache-managers/{cacheManagerName}/backups

Data Grid 使用所有备份名称的数组响应，如下例所示：

["backup1", "backup2"]

验证备份操作是否已完成。

HEAD /rest/v2/cache-managers/{cacheManagerName}/backups/{backupName}

200 响应表示备份存档可用。202 响应表示备份操作正在进行。

从服务器下载备份存档。

GET /rest/v2/cache-managers/{cacheManagerName}/backups/{backupName}

200 响应表示备份存档可用。202 响应表示备份操作正在进行。

从服务器中删除备份存档。

DELETE /rest/v2/cache-managers/{cacheManagerName}/backups/{backupName}

204 响应表示删除了备份存档。202 响应表示备份操作正在进行中，但在操作完成后会被删除。

从备份存档恢复 Data Grid 资源。提供的 {restoreName} 用于跟踪恢复进度，独立于正在恢复的备份文件的名称。

POST /rest/v2/cache-managers/{cacheManagerName}/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/cache-managers/{cacheManagerName}/restores

Data Grid 使用所有恢复名称的数组响应，如下例所示：

["restore1", "restore2"]

验证恢复操作是否已完成。

HEAD /rest/v2/cache-managers/{cacheManagerName}/restores/{restoreName}

201 (Created) 响应表示恢复操作已完成。202 (Accepted) 响应表示备份操作正在进行中。

删除从服务器恢复请求的元数据。此操作会删除与恢复请求关联的所有元数据，但不会删除任何恢复的内容。如果删除了请求元数据，您可以使用请求名称来执行后续恢复操作。

DELETE /rest/v2/cache-managers/{cacheManagerName}/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

对缓存管理器执行跨站点操作，将操作应用到所有缓存。

GET /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/

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

GET /rest/v2/cache-managers/{cacheManagerName}/x-site/backups/{site}

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

POST /rest/v2/cache-managers/{cacheManagerName}/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/cache-managers/{cacheManagerName}/x-site/backups/{siteName}?action=start-push-state

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

查看有关使用 GET 请求的数据网格服务器的基本信息。

GET /rest/v2/server

Data Grid 使用 JSON 格式的服务器名称、代码名称和版本响应，如下例所示：

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

使用 GET 请求检索 Data Grid 服务器的缓存管理器列表。

GET /rest/v2/server/cache-managers

Data Grid 使用为服务器配置的缓存管理器名称的数组响应。

配置 Data Grid，以临时从客户端请求中排除特定的缓存。发送包括缓存管理器名称和缓存名称的空 POST 请求。

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

如果找不到缓存或缓存管理器，则 data Grid 会成功添加到忽略列表或 404 (Not Found) 中带有 204 （无内容 ）的响应。

使用 DELETE 请求从忽略列表中删除缓存。

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

如果未找到缓存或缓存管理器，则 data Grid 会成功从忽略列表中移除缓存或 404 (Not Found) 时响应 204 （无内容 ）。

确认使用 GET 请求会忽略缓存。

GET /rest/v2/server/ignored-caches/{cache-manager}

使用 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 格式的内存池和垃圾回收的信息做出响应。

使用 GET 请求检索 JVM 的当前线程转储。

GET /rest/v2/server/threads

Data Grid 使用当前线程转储以 文本/plain 格式进行响应。

使用 GET 请求检索 Data Grid 服务器的聚合报告。

GET /rest/v2/server/report

Data Grid 使用 tar.gz 存档响应，其中包含有关 Data Grid 服务器和主机的诊断信息的聚合报告。除了配置和日志文件外，报告还提供有关 CPU、内存、打开文件、网络套接字和路由、线程的详细信息。

使用 POST 请求停止 Data Grid 服务器。

POST /rest/v2/server?action=stop

Data Grid 使用 204 （无内容） 响应，然后停止运行。

使用 POST 请求关闭整个 Data Grid 集群。

POST /rest/v2/cluster?action=stop

Data Grid 使用 204 （无内容） 响应，然后执行整个集群的有序关闭。

使用 GET 请求和 ?action=stop&server 参数在 Data Grid 集群中关闭一个或多个特定服务器。

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

Data Grid 使用 204 （无内容） 做出响应。

创建备份存档 application/zip，其中包含当前存储在集群的缓存容器中的资源（缓存、模板、计数器、Protobuf 模式、服务器任务等）。

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 响应表示恢复操作正在进行中，操作完成后会被删除。

使用 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}。（可选）可以为日志记录器设置一个或多个附加器。如果没有指定附加器，则使用根日志记录器中指定的附加器。

如果操作成功完成，服务会返回 204 (No Content)。

使用 DELETE 请求删除现有日志记录器。

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

Data Grid 移除了 {loggerName} 标识的日志记录器，有效地恢复到使用根日志记录器配置。

如果操作成功处理，服务会返回响应代码 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"
  }
]

使用 POST 请求执行任务名称，以及前缀为 param 的必要参数的任务。

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

Data Grid 使用任务结果做出响应。

使用 PUT 或 POST 请求上传脚本任务。

提供该脚本作为请求的内容有效负载。在 Data Grid 上传脚本后，您可以使用 GET 请求执行该脚本。

POST /rest/v2/tasks/taskName

查看有关用户主体和 access-control 列表的信息。

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"
    ]
  }
}

清空集群中的 access-control 列表缓存。

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/some_principal

Data Grid 使用指定主体的可用角色列表进行响应。主体不需要在使用的域中。

["observer"]

向主体授予一个或多个新角色。

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

删除之前授予主体的一个或多个角色。

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