Apache Ignite is a distributed caching platform that allows for transactions. It is capable of scaling to 1000s of nodes, while providing high speed memory accesses.
The simplest ways to utilize ignite is as key-value pair. This allows a user to get up and running quickly.
Ignite can be executed as a standalone application or within the application utilizing it. As a standalone application it must be executed in a server mode. This means it will be responsible for storing and serving data. However when executed within another application, it can be started in server or client mode. In client mode, the application is not responsible for storing or serving data.
Ignite has two configuration steps prior to being used. The first is defining the cluster discovery mechanism and the second is defining the cache.
In Ignite the cluster is the set of nodes sharing the data contained with a cache or caches. Some samples that ignite provides to define the cluster are:
- Local Only: The cluster is this single node only
The simpliest way to set up a Ignite instance is to do the following:
Ignite ignite = Ignition.start()
This will start up your instance with system defaults.
Now once you have the main Cluster instance, you can define a cache. Once again many configuration values can be tuned depending on your use case. Some examples include:
- Backup numbers
- Management Type
- Eviction Type And many others. However the simplest way to define a cache is to just give it a name.
IgniteCache<Long, DTO> cache = ignite.createCache("SAMPLE_CACHE")
Putting it all together
From this point the on the idea of using the cache is dependent on the environment it must be placed into. As a sample I've put together a small Spring Boot Application that utilizes Ignite here. Compared to the code snippets above, there is not a whole lot of additional Ignite setup.
Not Discussed, but still Awesome
Ignite provides a lot of additional built in capabilities that are worth mentioning but not discussed above. Some of the ones that catch my eyes:
- Distributed computation
- Distributed locks
- Machine Learning modules
- Distributed atomic reference types
- Service Grid
- and many more.
As you can see, Apache Ignite is a flushed out caching system that provides many functionalities. I would highly recommend it when evaluating other solutions.
A simple playground of my own making for playing with Apache Ignite.
Intent is to add small sample applications in order to play with and experiment with features within Ignite.
A simple Spring Boot rest application that accesses Ignite and gets/sets values within the cache.
Single Responsibility Principle (or SRP) is one of the most important concepts in software development. The main idea of this concept is: all pieces of software must have only a single responsibility.