APACHE IGNITE Distributed Database For High-Performance Computing With In-Memory Speed

Core Features

Use Ignite as a traditional SQL database by leveraging JDBC drivers, ODBC drivers, or the native SQL APIs that are available for Java, C#, C++, Python, and other programming languages. Seamlessly join, group, aggregate, and order your distributed in-memory and on-disk data:

                                                            
                                                                SELECT country.name, city.name, MAX(city.population) as max_pop
                                                                FROM country JOIN city ON city.countrycode = country.code
                                                                WHERE country.code IN ('USA','BRA','ESP','JPN')
                                                                GROUP BY country.name, city.name
                                                                ORDER BY max_pop DESC LIMIT 3;
                                                            
                                                        
Start Using SQL

Ignite scales up and out across memory and disk. By default, Ignite operates in a pure in-memory mode. But, by toggling a single configuration setting, you can turn a cluster into a database that can grow beyond the cluster's memory capacity:

                                                            
                                                                <bean class="org.apache.ignite.configuration.IgniteConfiguration">
                                                                    <property name="dataStorageConfiguration">
                                                                        <bean class="org.apache.ignite.configuration.DataStorageConfiguration">
                                                                            <property name="defaultDataRegionConfiguration">
                                                                                <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
                                                                                    <property name="persistenceEnabled" value="true"/>
                                                                                </bean>
                                                                            </property>
                                                                        </bean>
                                                                    </property>
                                                                </bean>
                                                            
                                                        
                                                            
                                                                IgniteConfiguration cfg = new IgniteConfiguration();

                                                                DataStorageConfiguration storageCfg = new DataStorageConfiguration();

                                                                // Enable Ignite Persistence
                                                                storageCfg.getDefaultDataRegionConfiguration().setPersistenceEnabled(true);

                                                                // Using the new storage configuration
                                                                cfg.setDataStorageConfiguration(storageCfg);
                                                            
                                                        
                                                            
                                                            var cfg = new IgniteConfiguration
                                                            {
                                                                DataStorageConfiguration = new DataStorageConfiguration
                                                                {
                                                                    DefaultDataRegionConfiguration = new DataRegionConfiguration
                                                                    {
                                                                        Name = "Default_Region",
                                                                        PersistenceEnabled = true
                                                                    }
                                                                }
                                                            };
                                                            
                                                        
Learn More About Storage Engine

With traditional databases, for in-place calculations, you use stored procedures that are written in a language such as PL/SQL. With Ignite, you use modern JVM languages, C# or C++ to develop and execute custom tasks across your distributed database:

                                                            
                                                            // Broadcast the task to server nodes only.
                                                            IgniteCompute compute = ignite.compute(ignite.cluster().forServers());

                                                            // Each remote server node will execute the logic of the task/lambda below.
                                                            compute.broadcast(() -> System.out.println(
                                                                "Hello Node: " + ignite.cluster().localNode().id()));
                                                            
                                                        
                                                            
                                                            // Broadcast the task to server nodes only.
                                                            var compute = ignite.GetCluster().ForServers().GetCompute();

                                                            // Each remote server node will execute the custom PrintNodeIdAction task.
                                                            compute.Broadcast(new PrintNodeIdAction());
                                                            
                                                        
Start Using Compute APIs

Ignite can operate in a strongly consistent mode that provides full support for distributed ACID transactions. Transact across multiple cluster nodes, caches, tables, and partitions:

                                                            
                                                                IgniteTransactions transactions = ignite.transactions();

                                                                try (Transaction tx = transactions.txStart()) {
                                                                    Integer hello = cache.get("Hello");

                                                                    if (hello == 1)
                                                                        cache.put("Hello", 11);

                                                                    cache.put("World", 22);

                                                                    tx.commit();
                                                                }
                                                            
                                                        
                                                            
                                                                var transactions = ignite.GetTransactions();

                                                                using (var tx = transactions.TxStart()) {
                                                                    int hello = cache.Get("Hello");

                                                                    if (hello == 1) {
                                                                        cache.Put("Hello", 11);
                                                                    }

                                                                    cache.Put("World", 22);

                                                                    tx.Commit();
                                                                }
                                                            
                                                        
Learn More About Transactions

Ignite machine learning uses built-in algorithms and tools, as well as TensorFlow integration, to enable the building of scalable machine learning models and avoid costly data transfers. Train, deploy, evaluate, and update your ML and DL models continuously and at scale:

                                                            
                                                            // Create the trainer
                                                            KNNClassificationTrainer trainer = new KNNClassificationTrainer()
                                                            .withK(3).withIdxType(SpatialIndexType.BALL_TREE)
                                                            .withDistanceMeasure(new EuclideanDistance())
                                                            .withWeighted(true);

                                                            // Train the model
                                                            KNNClassificationModel knnMdl = trainer.fit(ignite, dataCache, vectorizer);

                                                            // Make a prediction
                                                            double prediction = knnMdl.predict(observation);
                                                            
                                                        
Start Using Ignite Machine Learning

With relational databases, you use triggers to react to certain events. With Ignite, you deploy continuous queries that are written in a modern programming language such as Java or C# and process streams of changes on the database and application side:

                                                            
                                                            ContinuousQuery qry = new ContinuousQuery<>();

                                                            // The callback that will be triggered on the application side.
                                                            qry.setLocalListener(new MyLocalListener());

                                                            // The callback that will be executed on the server side.
                                                            qry.setRemoteFilterFactory(new MyRemoteFilterFactory());

                                                            // Deploy the query in the cluster.
                                                            cache.query(query);
                                                            
                                                        
                                                            
                                                            var cache = ignite.GetOrCreateCache("myCache");

                                                            var query = new ContinuousQuery(
                                                                new MyLocalListener(), // Will be triggered on the application side.
                                                                new MyRemoteFilter()); // Will be executed on the server side.

                                                            // Deploy the query in the cluster.
                                                            var handle = cache.QueryContinuous(query);
                                                            
                                                        
Start Using Continuous Queries

How to Use

Applications Acceleration & Data Caching

Accelerate your existing applications by 100x using Ignite as an in-memory cache or in-memory data grid that is deployed over one or more external databases. Think of a cache that you can query with SQL, transact, and compute on.

Learn More
Applications Acceleration & Data Caching Diagram

Database For Mixed Workloads

Build modern applications that support transactional and analytical workloads by using Ignite as a database that scales beyond the available memory capacity. Ignite allocates memory for your hot data and goes to disk whenever applications query cold records.

Learn More
Distributed Database Diagram

High-Performance Computing

Execute kilobyte-size custom code over petabytes of data. Turn your Ignite database into a distributed supercomputer for low-latency calculations, complex analytics, and machine learning.

Learn More
High-Performance Compute Cluster Diagram