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.

Ignite offers thin clients to access Ignite from Python, PHP, and Node.JS. To access Ignite from other programming consider using Ignite binary client protocol, JDBC and ODBC drivers, or other client protocols listed below.

Getting Started Guides

The following getting started guides show how to start and use Apache Ignite in 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) << "]";
                        
                            from pyignite import Client

                            client = Client()
                            client.connect('127.0.0.1', 10800)

                            #Create cache
                            my_cache = client.create_cache('my cache')

                            #Put value in cache
                            my_cache.put('my key', 42)

                            #Get value from cache
                            result = my_cache.get('my key')
                            print(result)
                        
                            $client = new Client();

                            $client->connect(new ClientConfiguration('127.0.0.1:10800'));
                            $cache = $client->getOrCreateCache('myCache')->
                                setKeyType(ObjectType::INTEGER);

                            // put and get value
                            $cache->put(1, 'abc');
                            $value = $cache->get(1);
                        
                            const igniteClient = new IgniteClient();

                            await igniteClient.connect(new IgniteClientConfiguration('127.0.0.1:10800'));
                            const cache = (await igniteClient.getOrCreateCache('myCache')).
                                setKeyType(ObjectType.PRIMITIVE_TYPE.INTEGER);

                            // put and get value
                            await cache.put(1, 'abc');
                            const value = await cache.get(1);
                        

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.

Thin Clients

A thin client is a lightweight Ignite client that connects to the cluster via a standard socket connection. Ignite provides thin clients for Java, .NET, PHP, Python, and Node.JS.

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.