A short while back we released Infinispan 15 which delivered many improvements to the query API. This blog is an in-depth dive into some of these:
diff --git a/index.html b/index.html index a38bcb9338..9cd2c48bfa 100644 --- a/index.html +++ b/index.html @@ -154,7 +154,7 @@Boost Application Performance
Infinispan turbocharges applications by storing data closer to processing logic, which reduces latency and increases throughput.
Available as a Java library, you simply add Infinispan to your application dependencies and then you’re ready to store data in the same memory space as the executing code.
If you want to provision a data layer that is independent of your applications, you can use Infinispan Server for remote access to data with in-memory performance. Clients are a single network hop away from data through consistent hashing techniques and can make requests over HTTP or with a custom binary TCP protocol called Hot Rod.
- Learn More + Learn MoreBoost Application Performance
Achieve High Availability and Elasticity
Infinispan provides trusted open-source technology to deliver scalability to meet workload demands and reduce resource utilization. At the same time, Infinispan distributes your data across clusters so no single point of failure causes data loss.
One popular use for Infinispan is as a shared store for stateful data, such as user HTTP sessions. Applications can stay lightweight and avoid heap usage by externalizing sessions to Infinispan clusters, which act as an independent data layer.
- Learn More + Learn More
@@ -181,7 +181,7 @@ Backup Across Data Centers
Infinispan clusters running in different geographical locations can form global clusters to back up your data across sites. If sites go offline clients can immediately switch to an available cluster, making sure data center faults do not cause service interruptions.
When using the Infinispan Operator with Kubernetes environments such as Red Hat OpenShift, cross-site replication capabilities make your data ready for hybrid and multi cloud deployments.
Infinispan also guarantees data consistency when using cross-site replication, even in cases where clients make concurrent writes at different locations that use asynchronous replication. So your data is always there and always accurate, no matter where you’re running.
- Learn More + Learn MoreBackup Across Data Centers
+Infinispan clusters running in different geographical locations can form global clusters to back up your data across sites. If sites go offline clients can immediately switch to an available cluster, making sure data center faults do not cause service interruptions.
+ +When using the Infinispan Operator with Kubernetes environments such as Red Hat OpenShift, cross-site replication capabilities make your data ready for hybrid and multi cloud deployments.
+ +Infinispan also guarantees data consistency when using cross-site replication, even in cases where clients make concurrent writes at different locations that use asynchronous replication. So your data is always there and always accurate, no matter where you’re running.
+ + +
+ Infinispan is released under the Apache 2.0 open source license. Learn more about the Apache Software License 2.0.
This website built with Jekyll is hosted on Github Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.
+
+ 
+ +
+
+ +
+ 
+ 
Boost Application Performance
+Infinispan turbocharges applications by storing data closer to processing logic, which reduces latency and increases throughput.
+ +Available as a Java library, you simply add Infinispan to your application dependencies and then you’re ready to store data in the same memory space as the executing code.
+ +If you want to provision a data layer that is independent of your applications, you can use Infinispan Server for remote access to data with in-memory performance. Clients are a single network hop away from data through consistent hashing techniques and can make requests over HTTP or with a custom binary TCP protocol called Hot Rod.
+ + + +
+ Infinispan is released under the Apache 2.0 open source license. Learn more about the Apache Software License 2.0.
This website built with Jekyll is hosted on Github Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.
+
+
+ +
+
+ +
+
+ Achieve High Availability and Elasticity
+Infinispan provides trusted open-source technology to deliver scalability to meet workload demands and reduce resource utilization. At the same time, Infinispan distributes your data across clusters so no single point of failure causes data loss.
+ +One popular use for Infinispan is as a shared store for stateful data, such as user HTTP sessions. Applications can stay lightweight and avoid heap usage by externalizing sessions to Infinispan clusters, which act as an independent data layer.
+ + +
+ Infinispan is released under the Apache 2.0 open source license. Learn more about the Apache Software License 2.0.
This website built with Jekyll is hosted on Github Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.
+
+
+ +
+
+ +
+
+ Use Cases
-Infinispan is a highly flexible data store that optimizes application performance and reduces operational costs
+Use Infinispan in real-world applications
+ +Here you will find examples that show how to use Infinispan features applied to real-world use-cases.
+ + -
- Boost Application Performance
-Infinispan turbocharges applications by storing data closer to processing logic, which reduces latency and increases throughput.
-Available as a Java library, you simply add Infinispan to your application dependencies and then you’re ready to store data in the same memory space as the executing code.
-If you want to provision a data layer that is independent of your applications, you can use Infinispan Server for remote access to data with in-memory performance. Clients are a single network hop away from data through consistent hashing techniques and can make requests over HTTP or with a custom binary TCP protocol called Hot Rod.
- Learn More -Achieve High Availability and Elasticity
-Infinispan provides trusted open-source technology to deliver scalability to meet workload demands and reduce resource utilization. At the same time, Infinispan distributes your data across clusters so no single point of failure causes data loss.
-One popular use for Infinispan is as a shared store for stateful data, such as user HTTP sessions. Applications can stay lightweight and avoid heap usage by externalizing sessions to Infinispan clusters, which act as an independent data layer.
- Learn More -
- 
- Backup Across Data Centers
-Infinispan clusters running in different geographical locations can form global clusters to back up your data across sites. If sites go offline clients can immediately switch to an available cluster, making sure data center faults do not cause service interruptions.
-When using the Infinispan Operator with Kubernetes environments such as Red Hat OpenShift, cross-site replication capabilities make your data ready for hybrid and multi cloud deployments.
-Infinispan also guarantees data consistency when using cross-site replication, even in cases where clients make concurrent writes at different locations that use asynchronous replication. So your data is always there and always accurate, no matter where you’re running.
- Learn More -Replace Memcached with Infinispan
+ +Why ?
+Memcached is a popular in-memory cache. However it has a number of limitations:
+ +-
+
- Memcached does not implement persistence, so restarting a server means that all data is lost. +
- Memcached does not implement transactions. +
- Memcached does not implement geographical replication. +
Infinispan is an in-memory database which does not have any of the above limitations, and offers even more advanced features. +Infinispan understands both the text and binary protocols implemented by Memcached, so you can connect to it with any compatible Memcached client without changing any configuration.
+ +Requirements
+ +-
+
- An application which uses a Memcached client for caching. +
- Infinispan Server. +
Instructions
+ +docker run -p 11222:11222 -p 11211:11211 quay.io/infinispan/server -c infinispan-memcached.xml
+Now you can connect to the server using your Memcached clients as you normally would.
+ +$ telnet 127.0.0.1 11211
+Trying 127.0.0.1...
+Connected to 127.0.0.1.
+Escape character is '^]'.
+set foo 0 300 3
+bar
+STORED
+get foo
+VALUE foo 0 3
+bar
+END
+delete foo
+DELETED
+flush_all
+OK
+
+The server listens on two ports:
+ +-
+
11211the default Memcached port with no authentication enabled.
+ 11222the default Infinispan server port with automatically generated username and password which are printed on startup. Connect to this with a browser to access the Infinispan administration console.
+
Further reading
+ + + +
+ Infinispan is released under the Apache 2.0 open source license. Learn more about the Apache Software License 2.0.
This website built with Jekyll is hosted on Github Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.
+
+
+ +
+
+ +
+
+ Replace Redis with Infinispan
+ +Why ?
+Redis is a very popular in-memory database with a huge number of clients available in many languages. However it has a number of limitations:
+ +-
+
- Redis is single-threaded, so performance is limited by that of a single core. +
- Redis is not open-source, but source-available, so that limits what you can do with it. +
- Redis transactions do not work in clustered mode. +
- Redis databases share a single configuration and do not work in clustered mode. +
- Redis expiration is configured only at the client level. +
- Redis authentication is very simple and does not integrate with external Identity Providers (IdPs), such as OAuth2, LDAP, etc. +
- Redis geographical replication is only available in the non-free Enterprise product. +
- Redis’ official Kubernetes Operator is only available in the non-free Enterprise product. +
Infinispan is also an in-memory database which does not have any of the above limitations, and offers even more advanced features. +Infinispan understands the RESP3 protocol used by Redis, so you can connect to it with any compatible Redis client without changing any configuration.
+ +Requirements
+ +-
+
- An application which uses a Redis client for caching/storage. +
- Infinispan Server. +
Instructions
+ +Start the Infinispan Server image using the infinispan-resp.xml configuration.
docker run -p 11222:11222 -p 6379:6379 quay.io/infinispan/server -c infinispan-resp.xml
+Now you can connect to the server using your Redis clients as you normally would.
+ +$ redis-cli
+127.0.0.1:6379> set k1 v1
+OK
+127.0.0.1:6379> get k1
+"v1"
+127.0.0.1:6379> del k1
+(integer) 1
+127.0.0.1:6379> exists k1
+(integer) 0
+127.0.0.1:6379> incr counter
+(integer) 1
+127.0.0.1:6379> decr counter
+(integer) 0
+The server listens on two ports:
+ +-
+
6379the default Redis port with no authentication enabled.
+ 11222the default Infinispan server port with automatically generated username and password which are printed on startup. Connect to this with a browser to access the Infinispan administration console.
+
Further reading
+ + + +
+ Infinispan is released under the Apache 2.0 open source license. Learn more about the Apache Software License 2.0.
This website built with Jekyll is hosted on Github Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.
+
+
+ +
+
+ +
+
+ Side-Caching with Infinispan
+ +Why ?
+Caching is a technique that can significantly improve the performance, efficiency, and user experience of your application. Here are several key reasons to use caching:
+ +-
+
- Improved Performance and Speed: storing frequently accessed data in a location closer to the application reduces the time required to retrieve the data compared to fetching it from the original source (like a database or external API) and makes responding to user requests faster. +
- Reduced Load on Backend Resources: caching reduces the number of direct queries to the database, minimizing the load and allowing the database to handle other operations more efficiently. By using techniques such as near-caching, which stores frequently accessed data inside your application, network traffic can be reduced. +
- Cost Efficiency and Scalability: achieve operational cost savings by reducing the need for frequent database queries or external API calls. By caching results of expensive computations, you avoid repeating the same computations multiple times. Caching can also help your application scale more effectively by handling a higher volume of requests without requiring a proportional increase in backend resources. +
- Improved Reliability and Availability: if the original data source becomes unavailable, cached data can still be served, providing a level of fault tolerance. Also, during traffic spikes, caches can handle more requests by serving precomputed responses, reducing the risk of downtime or degraded performance caused by backend overload. +
- Flexibility in Data Management: caches can be configured with various expiration policies (such as time-to-live) to ensure that data remains fresh and up-to-date as needed. +
Side-caching uses the Typical Cache Update Pattern (or TCUP). Given an architecture with three components, an application, a backend service and a cache, the following sequence diagram explains the interactions between them:
+ + +Assuming U is the average latency between components in the above system, the overal latency of side-caching is:
-
+
2Ufor a cache hit
+ 5Ufor a cache miss (assuming storing the data in the cache doesn’t wait for the acknowledgment)
+
Requirements
+ +-
+
- A Java client Application. +
- A Backend service. +
- Infinispan Server. +
Instructions
+ +The following Java code snippet shows how your Application might invoke a hypothetical Backend service to retrieve the data for a widget identified by key:
// assumes that var client = HttpClient.newHttpClient();
+public String getWidget(String key) {
+ var uri = URI.create("http://backend/widgets/" + key);
+ var request = HttpRequest.newBuilder().uri(uri).build();
+ return client.send(request, BodyHandlers.ofString());
+}
+Now, let’s add some caching.
+ +Start the Infinispan Server image supplying some credentials:
+ +docker run -p 11222:11222 -e USER=infinispan -e PASS=secret quay.io/infinispan/server
+NOTE:: 11222 is the default Infinispan server port. Infinispan automatically recognizes the type of client (Hot Rod, HTTP, Redis, Memcached).
In the application, initialize Infinispan’s Hot Rod client and create a cache, if one does not already exist:
+ +RemoteCacheManager cacheManager = new RemoteCacheManager("hotrod://infinispan:secret@localhost:11222");
+var cache = cacheManager.administration().getOrCreateCache("widget-cache", new StringConfiguration("\"distributed-cache\":{}}"));
+By adopting the side-caching pattern, the method would look like:
+ +public String getWidget(String key) {
+ return cache.computeIfAbsent(key, k -> {
+ var uri = URI.create("http://backend/widgets/" + k);
+ var request = HttpRequest.newBuilder().uri(uri).build();
+ return client.send(request, BodyHandlers.ofString());
+ }, 1, TimeUnit.HOUR);
+}
+The above code leverages the Cache.computeIfAbsent() method to implement the compute value on a cache miss logic. It also specifies an expiration time of 1 hour, after which the entry will be removed from the cache.
+Instead of programmatically specifying the expiration timeout for each entry, it’s possible to do so in the cache configuration:
{
+ "distributed-cache": {
+ "expiration": {
+ "lifespan": "3600000"
+ }
+ }
+}
+Make it asynchronous
+ +The above code is synchronous. Converting it to use asynchronous calls is easy:
+ +public CompletionStage<String> getWidget(String key) {
+ return cache.computeIfAbsentAsync(key, k -> {
+ var uri = URI.create("http://backend/widgets/" + k);
+ var request = HttpRequest.newBuilder().uri(uri).build();
+ return client.sendAsync(request, BodyHandlers.ofString());
+ }, 1, TimeUnit.HOUR);
+}
+Further reading
+ + + +
+ Infinispan is released under the Apache 2.0 open source license. Learn more about the Apache Software License 2.0.
This website built with Jekyll is hosted on Github Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.
+
+
+ +
+
+ +
+
+ Learn about Infinispan by watching various recorded demos, presentations and
Devoxx France: Highly available IAM with multi-site Keycloak deployments in the cloud
Ryan Emerson and Alexander Schwartz explain how Keycloak's Highly Available architecture and highlight the essential role Infinispan plays in it.
Infinispan: a better server for your Redis clients
+Tristan walks you through how Infinispan can be used by your Redis clients and uses Redis Insight to show how to seamlessly scale up and down by adding nodes to the cluster on the fly.
+