Product Features

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

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

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

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

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

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

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.

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

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

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

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

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

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

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 can be configured with a Java Transaction API (JTA) transaction manager lookup class.

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

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

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

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

Ignite implements Spring Data CrudRepository that supports basic CRUD operations as well as provides access to Ignite SQL Grid.

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

Ignite provides a cluster-enabled implementation of ExecutorService.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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.

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

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.

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

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

Ignite nodes can automatically discover each other by using DiscoverySpi.

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

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

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

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