Multi-Language Support

Apache Ignite is developed predominantly in Java and, thus, can be deployed and used on numerous operating systems and architectures supported by Java Virtual Machine. For instance, you can find Ignite deployments running on Linux, Windows, Mac OS, Oracle Solaris operating systems and x86, x64, SPARC, PowerPC instruction set architectures.

Java APIs are provided for every Ignite feature available. The APIs allow to embed Ignite related logic directly in Java or Scala powered applications and interact with the cluster by means of SQL and key-value operations, execute distributed computations and machine learning algorithms, and do much more.

In addition to Java, Ignite natively supports .NET platform with C# and C++ languages. Both Ignite .NET and Ignite C++ APIs delegate most of the calls to Java using JNI. Here, it is worth mentioning that the JNI overhead is minimal and does not cause any performance degradation, especially in distributed environments where the network is a main contributor to the overall application performance.

You can interact with Ignite as you would with any other SQL storage, using standard JDBC or ODBC connectivity. Ignite also provides native SQL APIs for Java, .NET and C++ developers for better performance.

To access Ignite from other programming languages such as Python, Ruby, PHP or Node.JS consider using Ignite binary client protocol, JDBC and ODBC drivers, or other client protocols listed below.

Getting Started Guides

The getting started guides that show how to start and make use of Apache Ignite in a matter of minutes:

Code Examples
                            Ignite ignite = Ignition.ignite();

                            IgniteCache<Integer, String> cache = ignite.cache("myCache");

                            // Store keys in cache (values will end up on different nodes).
                            for (int i = 0; i < 10; i++)
                                cache.put(i, Integer.toString(i));

                            for (int i = 0; i < 10; i++)
                                System.out.println("Got [key=" + i + ", val=" + cache.get(i) + ']');
                        
                            using (var ignite = Ignition.Start())
                            {
                                var cache = ignite.GetOrCreateCache<int, string>("myCache");

                                // Store keys in cache (values will end up on different nodes).
                                for (int i = 0; i < 10; i++)
                                    cache.Put(i, i.ToString());

                                for (int i = 0; i < 10; i++)
                                    Console.WriteLine("Got [key={0}, val={1}]", i, cache.Get(i));
                            }
                        
                            // Get cache instance.
                            Cache<int, std::string> cache = grid.GetCache<int, std::string>("myCache");

                            // Store keys in cache (values will end up on different  nodes).
                            for (int i = 0; i < 10; ++i)
                            {
                                std::stringstream value;
                                value << i;

                                cache.Put(i, value.str());
                            }

                            for (int i = 0; i < 10; ++i)
                                std::cout << "Got [key=" << i << ", val=" << cache.Get(i) << "]";
                        
                           <?php
                                try {
                                    // Connecting to Ignite using pre-configured DSN.
                                    $dbh = new PDO('odbc:LocalApacheIgniteDSN');

                                    // Changing PDO error mode.
                                    $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

                                    // Executing the query. The salary field is an indexed field.
                                    $dbh->query('UPDATE Person SET salary = 42000 WHERE salary > 50000');

                                } catch (PDOException $e) {
                                    print "Error!: " . $e->getMessage() . "\n";
                                    die();
                                }
                            ?>
                        

More examples are available on GitHub:

Supported Drivers and Protocols
Feature Description
Ignite Native Client

Ignite Native Clients provide full functionality to remote applications connecting to the cluster. It allows to use the whole set of Ignite APIs, including SQL, key-value, transactions, compute, streaming, services, etc. The native clients can be used from Ignite Java, .NET or C++ APIs.

JDBC/ODBC Drivers

Ignite is shipped with JDBC/ODBC Drivers that allow you to retrieve distributed data from the cluster using standard SQL queries.

REST/HTTP

Ignite provides an HTTP REST client that gives you the ability to communicate with the grid over HTTP and HTTPS protocols using REST approach. REST APIs can be used to perform different operations, like read/write from/to the cluster, execute tasks, get various metrics and more.

Memcached

Ignite is Memcached compliant, which enables users to store and retrieve distributed data from Ignite cache using any Memcached compatible client, including Java, PHP, Python, Ruby, and other Memcached clients.

PHP PDO

PHP provides a lightweight, consistent interface for accessing databases named PHP Data Objects - PDO. With the usage of Apache Ignite's ODBC driver, it's possible to connect to an Apache Ignite cluster from a PHP application accessing and modifying data that is stored there.

Redis

Ignite is partially Redis compliant and enables users to store data in and retrieve from Apache Ignite caches using any Redis compatible client.