Infinispan Server includes an endpoint that implements the RESP3 protocol and allows you to interact with remote caches using Redis clients.
1. Using the RESP endpoint
Infinispan Server includes an experimental module that implements the RESP3 protocol. The RESP endpoint allows Redis clients to connect to one or several Infinispan-backed RESP servers and perform cache operations.
1.1. Enabling the RESP endpoint
Add the resp-connector to Infinispan Server configuration to enable the RESP endpoint.
You can enable the RESP endpoint with:
-
Standalone Infinispan Server deployments, exactly like standalone Redis, where each server instance runs independently of each other.
-
Clustered Infinispan Server deployments, where server instances replicate or distribute data between each other. Clustered deployments provides clients with failover capabilities.
-
Install Infinispan Server.
-
Open your Infinispan Server configuration for editing.
-
Add cache configuration to the
cache-containersection if required.Cache configuration cannot enable capabilities that violate the RESP protocol. For example, specifying expiration values in a cache for the RESP endpoint results in a fatal error at startup.
If the cache is defined you must define the key encoding as
application/octet-stream.Configure your cache value encoding with Protobuf encoding if you want to view cache entries in the Infinispan Console (
value media-type="application/x-protostream"). -
Add an
endpointdeclaration to your configuration. -
Add the
resp-connectorelement and specify the name of the cache to use with the RESP connector with thecacheattribute.You can use only one cache with the RESP endpoint.
-
Declare the security realm to use with the RESP endpoint with the
security-realmattribute, if required. -
Ensure that the endpoint declaration also adds a Hot Rod and REST connector.
-
Save the changes to your configuration.
When you start Infinispan Server check for the following log message:
[org.infinispan.SERVER] ISPN080018: Started connector Resp (internal)You can now connect to the RESP endpoint with a Redis client. For example, with the Redis CLI you can do the following to add an entry to the cache:
redis-cli -p 11222 --user username --pass password127.0.0.1:11222> SET k v
OK
127.0.0.1:11222> GET k
"v"
127.0.0.1:11222> quitRESP endpoint configuration
<endpoints>
<endpoint socket-binding="default" security-realm="default">
<resp-connector cache="mycache" />
<hotrod-connector />
<rest-connector/>
</endpoint>
</endpoints>{
"server": {
"endpoints": {
"endpoint": {
"socket-binding": "default",
"security-realm": "default",
"resp-connector": {
"cache": "mycache"
},
"hotrod-connector": {},
"rest-connector": {}
}
}
}
}server:
endpoints:
endpoint:
socketBinding: "default"
securityRealm: "default"
respConnector:
cache: "mycache"
hotrodConnector: ~
restConnector: ~1.2. Redis commands
The Infinispan RESP endpoint implements the following Redis commands:
| Command | Notes |
|---|---|
This commands includes all required fields, some are set to 0 as they do not apply to {Infinispan}. |
|
See MULTI. |
|
Behaves like FLUSHDB since {Infinispan} does not support multiple Redis databases yet. |
|
This implementation attempts to return all attributes that a real Redis server returns. However, in most cases, the values are set to 0, because they cannot be retrieved or don’t make any sense in {Infinispan}. |
|
Current implementation time complexity is O(N), where N is the size of the list. |
|
Current implementation is atomic for rotation (source and destination are the same list). For different lists there is relaxed consistency for concurrent operations or failures unless the resp cache is configured to used transactions. |
|
This command will return the memory used by the key and the value. It doesn’t include the memory used by additional metadata associated with the entry. |
|
This command will return the same fields as a real Redis server, but all values will be set to 0. |
|
Always returns an empty list of modules. |
|
The current implementation has a relaxed isolation level. Redis offers serializable transactions, but {Infinispan} provides a read-uncommitted isolation. |
|
Cursors are reaped in case they have not been used within a timeout (5 minutes) |
|
Always returns |
|
:leveloffset: 1 :!context: :leveloffset!: |