Ignite Components

Apache Ignite In-Memory Data Fabric comprises the following set of components shared across the Ignite platform.


Ignite Feature Summary

The following is a summary of list of features currently available in Apache Ignite.

Data Grid

Key-Value Store

Ignite data grid is an in-memory key-value store which can be viewed as a distributed partitioned hash map.

Partitioning & Replication

Ignite can be configured to store the data in memory in either partitioned or replicated manner.

Client-Side (Near) Cache

Near cache is local client-side cache that stores the most recently and most frequently accessed data.

Collocated Processing

Ignite allows executing any native Java, C++, and .NET/C# code directly on the server-side, close to the data, in collocated fashion.

Self-Healing Cluster

Ignite cluster can self-heal, where clients automatically reconnect in case of failures.

On-Heap Memory

Ignite stores all cache entries on-heap to provide fast data access.

Off-Heap Memory

Storing data in off-heap memory allows your cache to overcome lengthy JVM Garbage Collection (GC) pauses.

Off-Heap Indexes

Whenever configured with off-heap memory, Ignite will store query indexes off-heap as well.

Tiered Storage

Ignite provides tiered storage model, where data can be stored and moved between on-heap, off-heap, and swap space.

Binary Protocol

Starting from v1.5 Ignite introduced a new concept of storing data in caches, called BinaryObjects. It allows you to:

  • Read a serialized object's field without full object deserialization.
  • Dynamically change an object's structure.
  • Dynamically create an object.
ACID Transactions

Ignite provides fully ACID compliant distributed transactions that ensure guaranteed consistency.

Deadlock-Free Transactions

Ignite supports deadlock-free, optimistic transactions, which do not acquire any locks.

Transactional Entry Processor

Ignite transactional entry processor allows executing collocated user logic on the server side within a transaction.

Cross-Partition Transactions

In Ignite, transactions can be performed on all partitions of a cache across the whole cluster.


Ignite allows developers to define explicit locks enforcing mutual exclusion on cached objects.

SQL Queries

Ignite supports the standard SQL syntax (ANSI 99) to query the cache. You can use any SQL function, aggregation, or grouping.

Collocated Joins

Ignite supports SQL joins on collocated data stored across multiple caches.

Non-Collocated Joins

Ignite offers non-collocated SQL joins for cases where it is extremely difficult to collocate all the data.

Continuous Queries

Ignite allows you to execute a query and continue to get notified about the data changes that fall into your query filter.

Query Indexing

For SQL queries, ignites supports in-memory indexing, so all the data lookups are extremely fast.

Query Consistency

In Ignite, provides full query consistency. Updates that happened after the query execution started do not affect the query result.

Query Fault-Tolerance

Ignite queries are fault-tolerant, i.e. query result is always consistent and is not affected by cluster topology changes.

JDBC Driver

Ignite JDBC driver allows users to retrieve data from cache using standard SQL queries and JDBC API.

ODBC Driver

Ignite ODBC driver allows users to retrieve data from cache using standard SQL queries and ODBC API.


Write-Through mode allows updating the data in the database.


Read-Through mode allows reading the data from the database.

Write-Behind Caching

Ignite provides an option to asynchronously perform updates to the database via Write-Behind Caching.

Automatic Persistence

Automatically connect to the underlying database and generate XML OR-mapping configuration and Java domain model POJOs.


Ignite is a 100% compliant implementation of JCache (JSR 107) specification.


Ignite supports retrieving distributed data from cache using standard SQL queries, JDBC and ODBC API.


Ignite can be configured with a Java Transaction API (JTA) transaction manager lookup class.

OSGI Support

Database Integration

Ignite can automatically integrate with external databases - RDBMS, NoSQL, and HDFS.

Hibernate L2 Cache

Ignite In-Memory Data Grid can be easily plugged in as a second level(L2) cache which is visible to all sessions.

Web Session Clustering

Ignite is capable of caching web sessions of all Java Servlet containers that follow Java Servlet 3.0 Specification.

Spring Caching

Ignite provides an implementation of SpringCacheAbstraction - an annotation-based way to enable caching for Java methods.

Java & JVM-based Platforms

Ignite is developed predominantly in Java and provides native support for JVM based languages such as Scala.


Ignite.NET is built on top of Ignite. This allows you to perform almost all the in-memory data grid operations including ACID transactions, SQL queries, distributed joins, messaging and events, etc.


Ignite C++ is built on top of Ignite. This allows you to perform almost all the in-memory data grid operations including SQL queries, and distributed joins.


Compute Grid

Distributed Closure Execution

Ignite compute grid allows to broadcast and load-balance any closure within the cluster or a cluster group.

Clustered Executor Service

Ignite provides a cluster-enabled implementation of ExecutorService.

MapReduce and ForkJoin

Ignite provides a ComputeTask API, which is a light-weight MapReduce (or ForkJoin) implementation.

Collocation of Compute & Data

Collocation of computations with data allow for minimizing data serialization within the network.


Checkpointing can be useful when long running jobs need to store some intermediate state to protect from node failures.


In case of a node crash, Ignite jobs are automatically transferred to other available nodes for re-execution.

Load Balancing

Ignite balances job distribution among cluster nodes, making sure that every node in the cluster is equally loaded.

Job Scheduling

Ignite provides a fine-grained control over jobs ordering once they arrive to a specific cluster node for execution.


Streaming Features

Data Streamers

Ignite allows you to process continuous never-ending streams of data into Ignite caches, in scalable and fault-tolerant fashion.

Collocated Processing

Ignite stream receivers allow you to react to the streamed data in collocated fashion, directly on the nodes where it will be cached.

Sliding Windows

Streaming allows querying into sliding windows of data. Sliding windows can be time-based, size-based, or batch-based.

Querying Sliding Windows

Ignite supports SQL, TEXT, and Predicate based cache queries to query into the streaming data.

Continuous Queries

Ignite allows you to execute a query and continue to get notified about the data changes that fall into your query filter.

JMS Data Streamer

Ignite JMS Data Streamer consumes messages from JMS brokers and inserts them into Ignite caches.

Apache Flume Sink

IgniteSink is a Flume sink that extracts events from an associated Flume channel and injects into an Ignite cache.

MQTT Streamer

Ignite MQTT Streamer consumes messages from a MQTT topic and feeds transformed key-value pairs into an Ignite cache.

Twitter Streamer

Ignite Twitter Streamer consumes messages from a Twitter Streaming API and inserts them into an Ignite cache.

Apache Kafka Streamer

Ignite Kafka Data Streamer consumes messages for a given Kafka Topic from Kafka Broker and inserts them into an Ignite cache.

Apache Camel streamer

Ignite Camel streamer consumes messages from an Apache Camel consumer endpoint and feeds them into an Ignite cache.

Apache Storm Streamer

Ignite Storm Streamer consumes messages from an Apache Storm consumer endpoint and feeds them into an Ignite cache.


Data Structures Features

Queue and Set

Ignite provides an implementation of a fast Distributed Blocking Queue and Distributed Set.

Collocated vs. Non-Collocated

Queues and Sets in Ignite can be deployed in a collocated or non-collocated mode.

Bounded Queues

Bounded queues allow users to have queues with predefined maximum size which gives a better control over the overall cache capacity.

Atomic Types

Ignite supports distributed AtomicLong and AtomicReference.


Ignite CountDownLatch allows you to synchronize jobs on all Ignite nodes.


Ignite distributed atomic sequence helps you to sequentially generate unique Ids across the cluster.


Ignite's distributed semaphore implementation and behavior is similar to java.util.concurrent.Semaphore.


Messaging & Events

Topic Based Messaging

Ignite distributed messaging allows for topic based cluster-wide communication between all nodes.

Point-to-Point Messaging

Ignite messages can be sent to either a group of nodes or to an individual node.

Ordered vs. Unordered

Ignite supports receiving messages in an ordered as well as unordered manner.

Event Notifications

Ignite distributed events functionality allows applications to receive notifications when a variety of events occur within the cluster.

Local vs. Remote Events

Applications can get notified for task executions, read, write or query operations occurring on local or remote nodes within the cluster.

Automatic Batching

In Ignite, event notifications can be grouped together and sent in batches or timely intervals.


Service Grid Features

User Defined Services

Ignite Service Grid allows for deployments of arbitrary user-defined services on the cluster.

Cluster Singletons

Ignite allows to deploy any number of services on any of the grid nodes, including singleton services.

Fault Tolerance

Ignite always guarantees that services are continuously available regardless of any topology changes.

Load Balancing

In all cases, other than singleton service deployment, Ignite deploys an equal number of services on each node within the cluster.


Spark Shared RDD

Ignite RDD

Apache Ignite provides an implementation of Spark RDD abstraction which allows to easily share state in memory across multiple Spark jobs.

SQL Queries

Running SQL queries using IgniteRDD is orders of magnitude faster than running SQL queries using Spark native RDDs or Data Frame APIs.


In-Memory File System

IGFS as Hadoop FileSystem

Ignite File System (IGFS) delivers similar functionality to Hadoop HDFS, but only in memory.

Hadoop FileSystem Cache

IGFS can also be deployed as a caching layer over another Hadoop File System.

On-Heap and Off-Heap

IGFS allows to store files either on-heap or off-heap.


Ignite comes with Hadoop Accelerator distribution which can be easily plugged into existing Hadoop installations.

Hortonworks HDP

Ignite comes with Hadoop Accelerator distribution which can be easily plugged into existing Hortonworks installations

Cloudera CDH

Ignite comes with Hadoop Accelerator distribution which can be easily plugged into existing Cloudera installations.


In-Memory MapReduce

Native Hadoop MapReduce

Apache Ignite comes with in-memory implementation of Hadoop MapReduce APIs.

Hadoop Accelerator

Accelerate existing Hadoop-based systems and products using a dual-mode, high performance in-memory file system.


Platform Independence


Ignite In-Memory Data Fabric is developed predominantly in Java, and provides native support for other languages - .NET and C++.


Ignite.NET is built on top of Ignite. This allows you to perform almost all the in-memory data grid operations supported in Ignite.


Ignite C++ is built on top of Ignite. This allows you to perform almost all the in-memory data grid operations supported in Ignite.


Supported Clients

Ignite Native Client

Ignite Native Clients provide full functionality of Ignite In-Memory Data Fabric to the remote clients connecting to the data fabric.

Memcached Support

Ignite allows users to store and retrieve data from Ignite caches using any Memcached compatible clients.


Ignite HTTP REST client gives you the ability to communicate with the grid over HTTP and HTTPS protocols using REST approach.


Ignite allows you to use SSL socket communication among all Ignite client and server nodes.



Zero Deployment

Ignite nodes automatically become aware of custom classes, eliminating the need to explicitly deploy them.

Dynamic Schema Changes

Ignite stores objects in binary format eliminating the need to deploy classes on server nodes.

Stand-Alone Clusters

Ignite nodes can automatically discover each other by using DiscoverySpi.

Public Clouds Support

Ignite integrates with Amazon Web Services, Google Compute Engine, and Apache JClouds.

Docker Container

Docker automates downloading the Ignite release, deploying users' library into Ignite, and configuring nodes.

Apache Mesos

Apache Ignite Framework supports scheduling and running Apache Ignite nodes in a Mesos cluster.

Hadoop Yarn

Integration with YARN supports scheduling and running Apache Ignite nodes in a YARN cluster.

OSGI Support