GridGain

The GridGain Developer Hub

Welcome to the GridGain developer hub. You'll find comprehensive guides and documentation to help you start working with GridGain as quickly as possible, as well as support if you get stuck. Let's jump right in!

Get Started    

Getting Started

This page will help you get started with GridGain. You'll be up and running in a jiffy!

Prerequisites

GridGain was officially tested on:

Name
Value

JDK

Oracle JDK 7 and above
Open JDK 7 and above
IBM JDK 7 and above

OS

Linux (any flavor),
Mac OSX (10.6 and up)
Windows (XP and up),
Windows Server (2008 and up)
Oracle Solaris

ISA

x86, x64, SPARC, PowerPC

Network

No restrictions (10G recommended)

Installation

Here is the quick summary on installation of GridGain Enterprise Edition:

  • Download GridGain IMDF as ZIP archive from http://www.gridgain.com/download/editions/
  • Unzip ZIP archive into the installation folder in your system
  • Set IGNITE_HOME environment variable to point to the installation folder and make sure there is no trailing / in the path (this step is optional)

Configuration

GridGain is based on Apache Ignite project and adds enterprise features as a plugin. All functionality that is available in Ignite is available in GridGain without any API changes. Refer to Ignite documentation for more information.

GridGain reuses Ignite's system properties, environment properties, startup scripts, etc. wherever possible. E.g., you will start a GridGain node with ignite.sh script, but you will get all enterprise features, because GridGain plugin will be automatically enabled.

GridGain plugin is enabled automatically with default settings. If you need to modify them (add security, portable objects, data center replication, etc.), you should use GridGainConfiguration class. This implements Ignite's PluginConfiguration interface, so can be set via IgniteConfiguration.setPluginConfigurations() configuration property.

For example, if you want to enable security, you can configure it using GridGainConfiguration.setSecurityCredentialsProvider() method:

// Ignite configuration.
IgniteConfiguration igniteCfg = new IgniteConfiguration();
 
// GridGain plugin configuration.
GridGainConfiguration gridCfg = new GridGainConfiguration();

// Create security credentials.
SecurityCredentials creds = new SecurityCredentials("username", "password");

// Create basic security provider.
SecurityCredentialsBasicProvider provider = new SecurityCredentialsBasicProvider(creds);

// Specify security provider in GridGain Configuration.
gridCfg.setSecurityCredentialsProvider(provider);

Start From Command Line

A GridGain node can be started from command line either with default configuration or by passing a configuration file. You can start as many nodes as you like and they will all automatically discover each other.

With Default Configuration

To start a grid node with default configuration, open the command shell and, assuming you are in IGNITE_HOME (GridGain installation folder), just type this:

$ bin/ignite.sh

and you will see the output similar to this:

[02:49:12] Ignite node started OK (id=ab5d18a6)
[02:49:12] Topology snapshot [ver=1, nodes=1, CPUs=8, heap=1.0GB]

By default ignite.sh starts a node with the default configuration: config/default-config.xml.

Passing Configuration File

To pass configuration file explicitly, from command line, you can type ignite.sh <path to configuration file> from within your Ignite installation folder. For example:

$ bin/ignite.sh examples/config/example-cache.xml

Path to configuration file can be absolute, or relative to either IGNITE_HOME (GridGain installation folder) or META-INF folder in your classpath.

Interactive Mode

To pick a configuration file in interactive mode just pass -i flag, like so: ignite.sh -i.

Get It With Maven

Another easy way to get started with GridGain in your project is to use Maven's dependency management.

GridGain requires only one gridgain-core as a mandatory dependency. Usually you will also need to add ignite-spring for spring-based XML configuration and ignite-indexing for SQL queries.

Replace ${gridgain.version} with actual GridGain Enterprise Edition version and ${ignite.version} with actual Apache Ignite or GridGain Professional Edition version.

Finally, in order to use GridGain Enterprise or Professional Editions' libraries you have to add GridGain's External Repository to the maven configuration file as it's shown in the example below.

<repositories>
    <repository>
        <id>GridGain External Repository</id>
        <url>http://www.gridgainsystems.com/nexus/content/repositories/external</url>
    </repository>
</repositories>
 
<dependency>
    <groupId>org.gridgain</groupId>
    <artifactId>gridgain-core</artifactId>
    <version>${gridgain.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-spring</artifactId>
    <version>${ignite.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-indexing</artifactId>
    <version>${ignite.version}</version>
</dependency> 

First GridGain Compute Application

Let's write our first grid application which will count a number of non-white-space characters in a sentence. As an example, we will take a sentence, split it into multiple words, and have every compute job count number of characters in each individual word. At the end we simply add up results received from individual jobs to get our total count.

try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
  Collection<IgniteCallable<Integer>> calls = new ArrayList<>();
 
  // Iterate through all the words in the sentence and create Callable jobs.
  for (final String word : "Count characters using callable".split(" "))
    calls.add(word::length);
 
  // Execute collection of Callables on the grid.
  Collection<Integer> res = ignite.compute().call(calls);
 
  // Add up all the results.
  int sum = res.stream().mapToInt(Integer::intValue).sum();
  
  System.out.println("Total number of characters is '" + sum + "'.");
} 
try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
    Collection<IgniteCallable<Integer>> calls = new ArrayList<>();
  
    // Iterate through all the words in the sentence and create Callable jobs.
    for (final String word : "Count characters using callable".split(" ")) {
        calls.add(new IgniteCallable<Integer>() {
            @Override public Integer call() throws Exception {
                return word.length();
            }
        });
    }
  
    // Execute collection of Callables on the grid.
    Collection<Integer> res = ignite.compute().call(calls);
  
    int sum = 0;
  
    // Add up individual word lengths received from remote nodes.
    for (int len : res)
        sum += len;
  
    System.out.println(">>> Total number of characters in the phrase is '" + sum + "'.");
} 

Zero Deployment

Note that because of Zero Deployment feature, when running the above application from your IDE, remote nodes will execute received jobs without explicit deployment.

First GridGain Data Grid Application

Now let's write a simple set of mini-examples which will put and get values to/from distributed cache, and perform basic transactions.

Since we are using cache in this example, we should make sure that it is configured. Let's use example configuration shipped with Ignite that already has several caches configured:

$ bin/ignite.sh examples/config/example-cache.xml
try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
    IgniteCache<Integer, String> cache = ignite.getOrCreateCache("myCacheName");
  
    // Store keys in cache (values will end up on different cache 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) + ']');
}
// Put-if-absent which returns previous value.
Integer oldVal = cache.getAndPutIfAbsent("Hello", 11);
   
// Put-if-absent which returns boolean success flag.
boolean success = cache.putIfAbsent("World", 22);
   
// Replace-if-exists operation (opposite of getAndPutIfAbsent), returns previous value.
oldVal = cache.getAndReplace("Hello", 11);
  
// Replace-if-exists operation (opposite of putIfAbsent), returns boolean success flag.
success = cache.replace("World", 22);
   
// Replace-if-matches operation.
success = cache.replace("World", 2, 22);
   
// Remove-if-matches operation.
success = cache.remove("Hello", 1); 
try (Transaction tx = ignite.transactions().txStart()) {
    Integer hello = cache.get("Hello");
   
    if (hello == 1)
        cache.put("Hello", 11);
   
    cache.put("World", 22);
   
    tx.commit();
} 
// Lock cache key "Hello".
Lock lock = cache.lock("Hello");
  
lock.lock();
  
try {
    cache.put("Hello", 11);
    cache.put("World", 22);
}
finally {
    lock.unlock();
}

GridGain Visor Admin Console

The easiest way to examine the content of the data grid as well as perform a long list of other management and monitoring operations is to use GridGain Visor GUI Utility.

To start Visor simply run:

$ bin/ggvisorui.sh

Getting Started

This page will help you get started with GridGain. You'll be up and running in a jiffy!