News

This week The apache Ignite book becomes one of the top books of leanpub

This week The apache Ignite book becomes one of the top books of leanpub.

Monday

Book review: The Apache Ignite book by Md Sadruddin

The book review was done by Md Sadruddin and publish on his web site itteratory.com. The part of the review is published here with permission by Md Sadruddin.

Last year, as I was working with Apache Ignite, I was desperately in search of a book that I could rely upon in terms of clearing my doubts. A book that would help me learn the product in a holistic manner. And as my search was on, I bumped into the book by Shamim Ahmed Bhuiyan, Michael Zheludkov, and Timur Isachenko. I was super impressed with it as I scanned through the book. I also put up a review of that version of the book here.


The product Apache Ignite has been evolving in a rapid speed. It introduced many new features, different architectural revamp etc as the new versions were released. But as the new features got added with the newly released versions, there came a need of the new version of the book covering these new features. I found out Shamim Ahmed Bhuiyan and Michael Zheludkov are already on their mission to release a new edition of the book. I was eagerly waiting for the same to be released. I scanned through the book as soon as I got hold of it. Here, in this blog, I’ll share my personal experience as I browsed through the book.


With the newer versions, the products evolved and gave tons of new features to explore and work on.
As I have already gone through the first version of the book, I thought of turning to new one again to update myself and gather an all-around knowledge about the new features, new architecture etc instead of relying only on the Ignite official documentation (which is a great knowledge center as well. No doubt!). This new book is excellent and it pleasantly caters to both developers and solution/technical architects community with utmost ease.
In this new version of the book, there are 10 chapters. In the very first chapter of "Introduction", the authors introduced the product, its evolution since its inception and comparison with other different products.


In the second chapter "Getting started with Apache Ignite", we get to know how to starta single node/multi-nodes Ignite instances. We get to learn how we can use docker to run Ignite instances. It also takes us through setting up SQL IDE where you can run SQL queries against cache. It also touches upon Apache Ignite SQLLINE cli. This chapter introduces us with the H2 database which is Ignite’s SQL engine. It also teaches us on how to use H2 web console. We can use this web console to administrate H2 database, run SQL queries etc. It also takes us through sample JAVA program to read/write from/to Ignite cache. It touches upon Apache Ignite thin client, REST API for manipulating cache.

In the third chapter called "Apache Ignite Use cases", the book introduces different possible use cases where Ignite can be used, various design decisions. This is a very helpful guide to the solution designers. 
After covering these basics, the authors then jump to the fourth chapter called "Architectural deep dive". It’s a long and massive chapter covering cluster topology, partitioning, replication strategy, different caching strategy etc. It covers Ignite’s positioning in the CAP triangle. It also covers durable memory architecture, paging, persistence feature and many other very useful features of the Ignite product. All in all, this chapter covers your need as an architect or solution designer. 
In the next chapter (fifth) called "Intelligent caching", the book details Ignite’s caching capabilities, use of this product for accelerating application performance. It covers many interesting topics like web session clustering, recommendation on preparing caching layer, best practices. It also presents many interesting examples. 
In the sixth chapter called "Database", the book details on the Ignite’s database features. This is also a long chapter covering Ignite native persistence, tables, indexes, joins and a plethora of other related concepts. As a solution designer, this is definitely one chapter that you will spend time on, in case you plan to use Ignite’s persistence feature i.e using Ignite as a database. 
In chapter seven, the book covers "Distributed computing" and touches upon how Ignite can be useful in modern day architectures like micro-services. It covers map-reduce, fork-join, collocation of computation and data. Another very useful chapter. 
In the eighth chapter, the book covers another big elephant topic "Streaming and complex event processing". Here authors details Ignite’s streaming and CEP capability and use cases where it can be used. 
In the next chapter nine, the book focuses on Ignite’s use in "Accelerating Big data computing" with good examples. 
In the final chapter ten, the book covers an essential topic on "Management and monitoring". It talks about Ignite’s built-in capabilities and also 3rd party tools that can be used to manage and monitor the Ignite cluster.
As in the previous version, one striking aspect of the book is its easy language. I also loved the way the authors explained various terminologies and jargon that are used in this book. As I read through the book, I had several design related questions and got the answers from the book itself. The book is self contained and I didn’t have to browse through the internet to understand different topics/concepts introduced by the authors. Real life examples and code fragments help explain different concepts and topics very easily. The code is also available in github for reference. You code as you read and that’s very cool!! The balance of theory, coding, examples make reading the book very fun filled and enlightening. You don’t get bored!
To conclude, this book has been very handy to me and the reading experience is fantastic. I definitely recommend this book to Ignite users; doesn’t matter if you are a developer, support team member, architect or solution designed. Everyone has got something or other to learn from this book and that too in an easy manner. All I can say is happy reading!! and comment below in case you have some questions on the book or just to share how your experience have been.
The book is currently available in the leanpub. You can check it out here.

Tuesday

Using Apache Ignite thin client - Apache Ignite insider blog

From the version 2.4.0, Apache Ignite introduced a new way to connect to the Ignite cluster, which allows communication with the Ignite cluster without starting an Ignite client node. Historically, Apache Ignite provides two notions of client and server nodes. Ignite client node intended as lightweight mode, which does not store data (however, it can store near cache), and does not execute any compute tasks. Mainly, client node used to communicate with the server remotely and allows manipulating the Ignite Caches using the whole set of Ignite API’s. There are two main downsides with the Ignite Client node:

  • Whenever Ignite client node connects to the Ignite cluster, it becomes the part of the cluster topology. The bigger the topology is, the harder it is for maintaining.
  • In the client mode, Apache Ignite node consumes a lot of resources for performing cache operations.

To solve the above problems, Apache Ignite provides a new binary client protocol for implementing thin Ignite client in any programming language or platforms.

Note that, word thin means, it doesn’t start any Ignite node for communicating with the Ignite cluster and doesn’t implement any discovery/communication SPI logic.

Thin client connects to the Ignite cluster through a TCP socket and performs CRUD operations using a well-defined binary protocol. The protocol is a fully socket-based, request- response style protocol. The protocol is designed to be strict enough to ensure standardization in the communication (such as connection handshake, message length, etc.), but still flexible enough that developers may expand upon the protocol to implement custom features.

Apache Ignite provides brief data formats and communication details in the documentation for using the binary protocol.Ignite already supports .NET, and Java thin client builds on top of the protocol and plans to release a thin client for major languages such as goLang, python, etc. However, you can implement your thin client in any favorite programming language of your choice by using the binary protocol.

Also note that, the performance of the Apache Ignite thin client is slightly lower than Ignite client node as it works through an intermediary node. Assume that, you have two nodes of the Apache Ignite A, B and you are using a thin client C for retrieving data from the cluster. With the thin client C, you have connected to the node B, and whenever you try to retrieve any data that belongs to the node A, the requests always go through the client B. In case of the Ignite client node, it sends the request directly to the node A.

Most of the times, you should not care about how the message formats look like, or the socket handshake performs. Thin client for every programming language encapsulates the ugly hard work under the hood for you. Anyway, if you want to have a deep dive into the Ignite binary protocol or have any issue to create your own thin client, please refer to the Ignite documentation.

Before moving on to more advanced topics, let’s have a look at a simple application to use Ignite thin client. In this simple application, I show you the bits and pieces you need to get started with the thin client. The source code for the examples is available at the GitHub repository, see chapter-2.

Step 1. Clone or download the project from the GitHub repository. If you are planning to develop the project from scratch, add the following maven dependency in your pom.xml file. The only ignite-core library need for the thin client, the rest of the libraries only used for logging.

<dependency>
    <groupId>org.apache.ignite</groupId>
    <artifactId>ignite-core</artifactId>
    <version>2.6.0</version>
</dependency>
<!-- Logging wih SLF4J -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.6.1</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.0.1</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.0.1</version>
</dependency>

Step 2. Now, let's create a new Java class with the name HelloThinClient.
Step 3. Copy and paste the following source code. Do not forget to save the file.

import org.apache.ignite.IgniteException;
import org.apache.ignite.Ignition;
import org.apache.ignite.client.ClientCache;
import org.apache.ignite.client.IgniteClient;
import org.apache.ignite.configuration.ClientConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloThinClient {
 private static final Logger logger = LoggerFactory.getLogger(HelloThinClient.class);
 private static final String HOST = "127.0.0.1";
 private static final String PORT = "10800";
 private static final String CACHE_NAME = "thin-cache";

 public static void main(String[] args) {
  logger.info("Simple Ignite thin client example working over TCP socket.");
  ClientConfiguration cfg = new ClientConfiguration().setAddresses(HOST + ":" + PORT);
  try (IgniteClient igniteClient = Ignition.startClient(cfg)) {
   ClientCache < String, String > clientCache = igniteClient.getOrCreateCache(CACHE\ _NAME);
   // put a few value
   clientCache.put("Moscow", "095");
   clientCache.put("Vladimir", "033");
   // get the region code of the Vladimir String val = clientCache.get("Vladimir");
   logger.info("Print value: {}", val);
  } catch (IgniteException e) {
   logger.error("Ignite exception:", e.getMessage());
  } catch (Exception e) {
   logger.error("Ignite exception:", e.getMessage());
  }
 }
}

Step 4. Let's have a closer look at the program we have written above.

private static final Logger logger = LoggerFactory.getLogger(HelloThinClient.class);
 private static final String HOST = "127.0.0.1";
 private static final String PORT = "10800";
 private static final String CACHE_NAME = "thin-cache";

First, we have declared a few constants: logger, host IP address, port and the cache name that we are going to create. If you have a different IP address, you should change it here. Port 10800 is the default for Ignite thin client.

СlientConfiguration cfg = new ClientConfiguration().setAddresses(HOST+":"+PORT);

These are our next exciting line in the program. We have created an instance of the Ignite СlientConfiguration and passed the address we declared above. In the next try-catch block, we have defined a new cache with name thin-cache and put 2 key-value pairs. We also used Ignition.startClient method to initialize a connection to Ignite node.

try (IgniteClient igniteClient = Ignition.startClient(cfg)) {
   ClientCache < String, String > clientCache = igniteClient.getOrCreateCache(CACHE\ _NAME);
   // put a few value
   clientCache.put("Moscow", "095");
   clientCache.put("Vladimir", "033");
   // get the region code of the Vladimir String val = clientCache.get("Vladimir");
   logger.info("Print value: {}", val);
  } catch (IgniteException e) {
   logger.error("Ignite exception:", e.getMessage());
  } catch (Exception e) {
   logger.error("Ignite exception:", e.getMessage());
  }
}

Later, we retrieved the value of key Vladimir and printed the value in the console.

Step 5. Start your Apache Ignite single node cluster if it is not started yet. Use the following command in your favorite terminal.

$ IGNITE_HOME/bin/ignite.sh

Step 6. To build the project, issue the following command.

$ mvn clean install

This will run Maven, telling it to execute the install goal. This goal will compile, test, and package your project code and then copy it into the local dependency repository. The first time the build process will take a few minutes to complete, after successful compilation, an executable jar named HelloThinClient-runnable.jar will be created in the target directory.

Step 7. Run the application by typing the following command.

$ java -jar .\target\HelloThinClient-runnable.jar

You should see a lot of logs into the terminal. At the end of the log, you should find something like this.

Figure 1.

The application connected through the TCP socket to the Ignite node and performed put and get operation on cache thin-cache. If you take a look at the Ignite node console, you should notice that Ignite cluster topology has not been changed.

Figure 2.