Get Started

Get Started

These guides demonstrate how to get started quickly with Hazelcast IMDG and Hazelcast Jet.

Hazelcast IMDG

Learn how to store and retrieve data from a distributed key-value store using Hazelcast IMDG. In this guide you’ll learn how to:

  • Create a cluster of 3 members.
  • Start Hazelcast Management Center
  • Add data to the cluster using a sample client in the language of your choice
  • Add and remove some cluster members to demonstrate data balancing capabilities of Hazelcast

Hazelcast Jet

Learn how to build a distributed data processing pipeline in Java using Hazelcast Jet. In this guide you’ll learn how to:

  • Install Hazelcast Jet and form a cluster on your computer
  • Build a simple pipeline that receives a stream of data, does some calculations and outputs some results
  • Submit the pipeline as a job to the cluster and observe the results
  • Scale the cluster up and down while the job is still running



Cloud-Ready, Simple to Scale, Unparalleled Speed.

Hazelcast IMDG offers simple scalability, partitioning (sharding), and re-balancing out of the box. It does not require any extra coordination processes. By comparison, NoSQL and traditional databases are difficult to scale out and manage. They require additional processes for coordination and high availability. With Hazelcast, when you start another process to add more capacity, data and backups are automatically and evenly balanced.

The most popular use case for Hazelcast IMDG is distributed in-memory caching. Hazelcast IMDG has flexible structures such as Maps, Sets, Lists, MultiMaps, Ringbuffers, and HyperLogLogs. Hazelcast IMDG retains all data in memory, so applications can achieve speeds far greater than traditional stores. Hazelcast IMDG is highly adaptable. It can slot into existing architectures and provide a single interface to multiple disparate data stores.

Hazelcast IMDG can run in any cloud using its multiple discovery plugins. It functions seamlessly in Kubernetes.


Work with language-native data structures

For Java developers

Hazelcast IMDG enables you to use familiar Java collections and concurrency interfaces and makes them distributed and highly available. You can:

  • Store terabytes of data in Java Collections without changing interfaces. Run distributed callables and runnables that run on the exact process where its required data resides.
  • Connect Java clients to the Hazelcast cluster. Hazelcast nodes are JVM-based, which allows applications to embed clustering.
  • Access the cluster from any JVM-based language.
  • Integrate with the wider Java ecosystem using libraries such as Spring Boot, Spring Data & Hibernate.


Elastically scale .NET caching for your real-world requirements. Hazelcast IMDG is an excellent Redis alternative when scaling and speed is of importance.

  • Use the Hazelcast Near Cache feature to store frequently read data in your .NET process. This provides faster read speeds than traditional caches such as Redis or Memcached. Eventual Consistency is also supported.
  • Access all of the Hazelcast data structures plus distributed queues, topics, and more with the Hazelcast IMDG .NET Client.
  • Provides SSL support and Mutual Authentication for your enterprise-level security needs.
  • Support JSON or serialized objects.

For Node.js developers

Hazelcast IMDG enables you to accelerate your Node.js applications and work with native Javascript objects or JSON. Turbocharge applications that currently use Redis or MongoDB. You can:

  • Use the Hazelcast Near Cache feature to store frequently read data in your Node.js process. This provides faster read speeds than traditional caches such as Redis or Memcached.
  • Query JSON data at speeds far surpassing traditional document stores such as MongoDB.
  • Store web session information in Hazelcast.

For Python developers

Hazelcast IMDG enables you to use an unparalleled range of massively scalable data structures with your Python applications. You can:

  • Use the Hazelcast Near Cache feature to store frequently read data in your Python process. This provides faster read speeds than traditional caches such as Redis or Memcached.
  • Access all of the Hazelcast data structures plus distributed queues, topics, and more with the Hazelcast IMDG Python Client.
  • Support JSON or serialized objects.

For C++ developers

Extend the benefits of operational in-memory computing to your C++ applications running in Linux, Windows, and macOS.

  • Use the Hazelcast Near Cache feature to store frequently read data in your C++ process. This provides faster read speeds than traditional caches such as Redis or Memcached.
  • Access all of the Hazelcast data structures plus distributed queues, topics, and more with the Hazelcast IMDG C++ Client.
  • Provides SSL support for your enterprise-level security requirements.
  • Ability to discover the existing Hazelcast clusters in an AWS environment.
  • Asynchronously execute your tasks in the cluster, such as database queries, complex calculations, and image rendering.
  • Non-Blocking asynchronous methods for more powerful operations like batched writing or reading.
  • Ability to send multiple requests in parallel using a single thread via Pipelining API, which increases the throughput.

For Go developers

Hazelcast IMDG is a feature-rich and developer-friendly in-memory caching solution for your Go applications.

  • Access all of the Hazelcast data structures plus distributed queues, topics, and more with the Hazelcast IMDG Go Client.
  • Declarative configuration support via JSON.
  • High-performance aggregation functions, such as sum, average, max, and min, for Hazelcast Map entries. They can run in parallel for each partition and are highly optimized for speed and low-memory consumption.
  • Use the Projection API to strip down each result object in order to avoid redundant network traffic.

Use Cases

Much more than an in-memory data store

Database Caching
Database Caching

Hazelcast can be used as an in-line database cache. This means developers can continue to work with familiar data structure APIs in their own languages without having to resort to SQL or a NoSQL-specific API. Hazelcast takes care of read-through and write-through to the database at the backend. Read performance is improved to microseconds for cached data and writes to slow databases can be offloaded from the caller and saved to the database asynchronously. Hazelcast does not require the use of a cache aside pattern. Cache aside is required when using NoSQL solutions such as Redis. This generally means the developer must code for cache concerns such as read-through on a cache miss and write-through for saves. Cache aside patterns are also slower as they require more network hops.

Application Caching
Application Caching

Hazelcast Near Caches can be used to store frequently read data within the Application process itself. This means that any Java, .Net, Node.js, Python, C++ or Go programs can reduce their data lookup times from seconds over the network down to microseconds. Hazelcast Near Caches provide their own eviction and memory management facilities so you can be sure your application is safe. The same comments on cache aside mentioned in database caching are true for this use case, let Hazelcast take care of the caching flow, don’t write this logic into your own application.

Microservices Caching and Co-ordination
Microservices Caching and Co-ordination

Hazelcast clusters make excellent platforms for microservice messaging, coordination, and distribution. Hazelcast can facilitate many microservice patterns such as Saga, Datastore per Service, Shared Datastore & CQRS. Hazelcast’s concurrency primitives also provide useful API to coordinate access to services and provide HA services. Hazelcast Topics and Queues can be used to share events across a cluster of Hazelcast-enabled microservices. Hazelcast solves many of the platform challenges of microservices that would usually require separate database, messaging, and coordination software. Robust coordination primitives that can survive network partitions are crucial for microservices. Hazelcast’s concurrency packages are based on a CP subsystem that uses RAFT under the covers.

Cache-as-a-Service (CAAS)
Cache-as-a-Service (CAAS)

Hazelcast can be used to deliver a CAAS (Cache-as-a-Service), typically used where various applications need to share similar business data. Or when not shared, a CAAS makes sense to organizations that want to centralize and rationalize the number of data stores that applications have to connect to. A CAAS can (at the same time) sit over many different legacy data stores such as mainframes, relational databases, and NoSQL databases. Many different business areas and application teams make use of the same central CAAS. Because Hazelcast is schema-less and uses sensible defaults, teams can quickly save data to the CAAS without lengthy onboarding processes.

Web Session Clustering
Web Session Clustering

A popular use case for Hazelcast is the caching of web sessions. Web and application servers can easily be made to scale out to handle huge loads by adding devices such as a load balancer. This has a second effect of providing redundancy. However, for applications that use web sessions, this introduces a new problem. If a server goes down and the load balancer moves the user to a new server, the session is lost. Hazelcast stores the web session in its Distributed cache and provides easy to use native adapters for some of the most popular web servers such as Tomcat and Jetty or any other Java-based server via our generic filter based adapter.

NoSQL (Redis/MongoDB) Replacement
NoSQL (Redis/MongoDB) Replacement

NoSQL solutions such as Redis and MongoDB are hugely popular and provide a good fit for many use cases. However, consider using Hazelcast when you are finding NoSQL software is becoming hard to live with, especially when trying to scale and manage in general. Hazelcast has been designed as a clustered and highly available system from day one; Redis, for example, has not. Hazelcast scalability is a matter of adding another process to the cluster, there is no operational downtime or manual intervention (re-sharding) required. Also, consider Hazelcast when you require improved latency. Don’t take our word for it, run your own benchmarks against Redis or MongoDB and find out for yourself. Also, when running the benchmarks definitely consider using features such as Hazelcast Near Cache.

Hazelcast understands and can query JSON documents making it a great replacement for MongoDB. Finally, Hazelcast can be embedded within your own Java applications as a cluster or as a client; something that NoSQL solutions such as Redis or MongoDB would definitely struggle with.

Massively Parallel Processing
Massively Parallel Processing

Hazelcast IMDG can run Java code within the cluster in the form of Callables or Runnable. These programs can be directed to the member of the cluster holding a certain key, or they can move their own processing data with them, as a true function. Because the processing can be split by key it allows all members of the cluster to actively work on jobs in parallel. As well as IMDG consider Hazelcast Jet for more advanced batch processing features in addition to its first-class support for stream processing.

Easy Messaging
Easy Messaging

One powerful capability offered by Hazelcast is the broadcast messaging system. This is inspired by JMS topics and offers a lighter weight alternative, publish events on a bus that can deliver to an arbitrary number of listeners. Hazelcast Topics is not a full JMS provider, but it is in use delivering millions of messages scalably at organizations like Ericsson and NTT of Japan.

Applications can publish a message onto a topic that will be distributed to all instances of the application that have subscribed to that topic. One of the primary benefits of this style of messaging is that it can reliably be scaled to many nodes, thus increasing the throughput of messages. Hazelcast lacks any single point of failure which is not easy to achieve with pure JMS solutions.

Hazelcast provides a distribution mechanism for publishing messages that are delivered to multiple subscribers which are also known as the publish/subscribe (pub/sub) messaging model. Publish and subscriptions are cluster-wide.

Free Hazelcast Online Training Center

Whether you're interested in learning the basics of in-memory systems, or you're looking for advanced, real-world production examples and best practices, we've got you covered.

Join Us On Slack