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.

Getting Started

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.

Configuration

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
• Multicast
• Service:
• ZooKeeper

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.

References: