Distributed caching-computing v3.8

Thinking Distributed: The Hazelcast
Way
RAHUL GUPTA
SR SOLUTIONS ARCHITECT

About Me
Senior Solutions Architect
Worked with Terracotta
In-memory Distributed Systems since 2009
Java Programmer since 1998
rahul@hazelcast.com
Rahul Gupta
follow me @wildnez

© 2017 Hazelcast Inc. Confidential & Proprietary 3
Hazelcast Reborn

1010110010000101001
1010110010001110101001
10111001001
10101100100001111010100
Challenges of Big
Data Management

Why Hazelcast?
• Scale-out Computing enables cluster capacity to be increased
or decreased on-demand
• Resilience with automatic recovery from member failures
without losing data while minimizing performance impact on
running applications
• Programming Model provides a way for developers to easily
program a cluster application as if it is a single process
• Fast Application Performance enables very large data sets to be
held in main memory for real-time performance

Low-Level Services API
Node Engine
(Threads, Instances, Eventing, Wait/Notify, Invocation)
Partition Management
(Members, Lite Members, Master Partition, Replicas, Migrations, Partition Groups, Partition Aware)
Cluster Management with Cloud Discovery SPI
(AWS, Azure, Consul, etcd, Heroku, IP List, Apache jclouds, Kubernetes, Multicast, Zookeeper)
Networking
(IPv4, IPv6)
On-Heap Store High-Density Memory Store
(Intel, Sparc)
Serialization
(Serializable, Externalizable, DataSerializable, IdentifiedDataSerializable, Portable, Custom)
Near Cache HD
C++ C#/.NET Python Node.js Scala
Memcached Clojure Open Client Network Protocol
(Backward & Forward Compatibility, Binary Protocol)
REST
Java
JVM
(JDK: 6, 7, 8, Vendors: Oracle JDK, Open JDK, IBM JDK, Azul Zing & Zulu)
Hardware/VM/Container
(On Premise, AWS, Azure, Docker, Pivotal Cloud Foundry, OpenShift, VMware)
Executor
Service
SQL Query MapReduce AggregationPredicate Entry Processor
Map MultiMap
Replicated
Map
Web Sessions
(Tomcat/Jetty/Generic)
Continuous
QueryHD
HD
Open Source Enterprise Edition
Hazelcast IMDG
Enterprise HD Edition HD-Enabled Feature
WAN
(Socket,SolaceSystems:One-way,Multiway,InitnewDataCenter,DRDataCenterRecovery)
ManagementCenter
(JMX/REST)
SecuritySuite
(Connection,Encryption,Authentication,Authorization,JAASLoginModule,SocketInterceptor)
Engine
Clients
HD
HD
HD
Queue Topic
Ring
Buffer
Atomic
Long
Hibernate 2nd Level
Cache HD
JCache
Set
Lock/
Sem.
HD
java.util.concurrent
UUID
Hot Restart Store
(SSD, HDD) HD
Storage
Operating System
(Linux, Oracle Solaris, Windows, AIX, Unix)
Operating
Env
APIs
Hyper
LogLog
RollingUpgrades
(RollingClientUpgrades,RollingMemberUpgrades,NoDowntime)
HazelcastStriimHotCache
(SyncUpdatesfromOracleDB,MSSQLServer,MySQLandNonStopDB)
Operations
Hazelcast Solution

Ecosystem Traction
Dozens of Commercial and Open Source Projects Embed Hazelcast

01001
10101
01010
In Memory
Data Computing
In Memory
Data Messaging++In Memory
Data Storage
In Memory Data Grid

Business Systems
A B C
RDBMS Mainframe
MongoDB
NoSQL
REST
Scale
Hazelcast
In-Memory Caching

java.util.concurrent.ConcurrentMap
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
public static void main(String[] args) {
ConcurrentMap<Integer, String> map = new ConcurrentHashMap<>();
map.put(1, "Paris");
map.put(2, "London");
map.put(3, "San Francisco");
String oldValue = map.remove(2);
}

Distributed Map
import java.util.concurrent.ConcurrentMap;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
public static void main(String[] args) {
HazelcastInstance h = Hazelcast.newHazelcastInstance();
ConcurrentMap<Integer, String> map = h.getMap("myMap");
map.put(1, "Paris");
map.put(2, "London");
map.put(3, "San Francisco");
String oldValue = map.remove(2);
}

Persistence API
public class MapStorage
implements MapStore<String, User>, MapLoader<String, User> {
// Some methods missing ...
@Override public User load(String key) { return loadValueDB(key); }
@Override public Set<String> loadAllKeys() { return loadKeysDB(); }
@Override public void delete(String key) { deleteDB(key); }
@Override public void store(String key, User value) {
storeToDatabase(key, value);
}
}
<map name="users">
<map-store enabled="true">
<class-name>com.hazelcast.example.MapStorage</class-name>
<write-delay-seconds>0</write-delay-seconds>
</map-store>
</map>

JCache API
// Retrieve the CachingProvider which is automatically baced by
// the chosen Hazelcast server or client provider
CachingProvider cachingProvider = Caching.getCachingProvider();
// Create a CacheManager
CacheManager cacheManager = cachingProvider.getCacheManager();
// Cache<String, String> cache = cacheManager
// .getCache( name, String.class, String.class );
// Create a simple but typesafe configuration for the cache
CompleteConfiguration<String, String> config =
new MutableConfiguration<String, String>()
.setTypes( String.class, String.class );

JCache API
// Create and get the cache
Cache<String, String> cache = cacheManager
.createCache( "example", config );
// Alternatively to request an already existing cache
Cache<String, String> cache = cacheManager
.getCache( name, String.class, String.class );
// Put a value into the cache
cache.put( "world", "Hello World" );
// Retrieve the value again from the cache
String value = cache.get( "world" );
System.out.println( value );

Eviction
• Unless deleted, entries remain in the map.
• Use eviction policies to prevent OOM situations.
• Eviction Triggers run LFU or LRU.
time-to-live
max-idle-seconds
max-size (PER_NODE(number of entries),
PER_PARTITION(number of entries),
USED_HEAP_SIZE(mb),
USED_HEAP_PERCENTAGE(mb))
• Setting eviction-percentage removes that % of entries when eviction is
triggered.

Features Description
MultiMap Store multiple values against one Key
Replicated Map Cluster wide replication, all entries on all nodes. Good for read heavy use
cases
Near Cache Map Entries on Client/Application local memory
RingBuffer Stores data in a ring-like structure, like a circular array with given capacity
More Distributed Structures

Java Collection API: Map, List, Set, Queue
Jcache
High Density Memory Store
Hibernate 2nd Level Cache
Web Session Replication: Tomcat, Jetty
Predicate API: Indexes, SQL Query
Persistence: Map/Queue Store & Loader. Write Behind/Through
Spring Compliance
Transactions: Local & XA
WAN & DR Replication
IM Data Store (Caching) Features

Java: Will it make the cut?
Garbage Collection limits heap usage. G1 and
Balanced aim for <100ms at 10GB.
Unused
Memory
64GB
4GB 4s
Heap
Java Apps Memory Bound
GC Pause
Time
Available
Memory
GC
Off-Heap Storage
No low-level CPU access
Java is challenged as an infrastructure language
despite its newly popular usage for this
Heap

GC Pause
64 Gb
JVM
4 Gb JVM 1
4 Gb JVM 2
4 Gb JVM 3
4 Gb JVM 4
4 Gb JVM 5
4 Gb JVM 16
GC Pause
0 GB
64 GB
64 Gb in-memory data
time
Standard Impediments of Caching

GC Pause
64 Gb
JVM
4 Gb JVM 1
4 Gb JVM 2
4 Gb JVM 3
4 Gb JVM 4
4 Gb JVM 5
4 Gb JVM 16
GC Pause
0 Gb
64 Gb
64 Gb in-memory data
time
64 Gb
HD
2 Gb JVM
GC Pause
HD Memory
Caching with HD Memory

On-Heap Memory Store
(Objects Stored as Objects)
High-Density Memory Store
(Objects Serialized and Stored as
Bytes)
s.m.Unsafe s.m.Unsafe
2-4GB
(Limited by Garbage
Collection)
0-1TB
(Limited by
Machine RAM)
Memory Stores
•Member
•Client
(Near Cache)
RAM in JVM Process
APIs
JCache
(ICache)
Map
(IMap)
HD Memory

On Heap Vs. High-Density
Memory Management
On Heap Memory HD Memory
0 MB HD 3.3 GB
3.9 GB Heap Storage 0.6 GB
9 (4900 ms) Major GC 0 (0 ms)
31 (4200 ms) Minor GC 356 (349 ms)
Node Used
Heap
Total
Heap
Max.
Heap
Heap Usage
Percentage
Used Heap: 0.2 GB
192.168.1.10:5701 57 MB 229 MB 910 MB 6.28%
Memory Utilization
Home Offheap-test
Node Used Heap: 3.9 GB
192.168.1.10:5701 3933 MB 4658MB 4653MB 84.45%
Memory Utilization
Home
Used
Heap
Total
Heap
Max.
Heap
Heap Usage
Percentage
Example: On Heap Memory Example: HD Memory

Hazelcast Servers
Hazelcast Server
JVM [Memory]
A B C
Business Logic
Data Data Data
CE = Compute Engine
Result
Business / Processing Logic
Result
TCP / IP
Client Client
Distributed Computing

IM Distributed Computing Feature
HD
Cache
Dist.
Compute
Dist.
Message
Java Concurrency API
(Lock, Semaphore, AtomicLong, AtomicReference, Executor Service, Blocking Queue)
Entry and Item Listeners
Entry Processor
Aggregators
Map/Reduce
Data Affinity
Continues Query
Map Interceptors
Delta Update

Executor Service API
public interface com.hazelcast.core.IExecutorService
extends java.util.concurrent.ExecutorService
HazelcastInstance hz = getHazelcastInstance();
//java.util.concurrent.ExecutorService implementation
IExecutorService es = hz.getExecutorService("name");
es.executeOnAllMembers(buildRunnable());
es.executeOnKeyOwner(buildRunnable(), "Peter");
es.execute(buildRunnable());
Map<..> futures = es.submitToAllMembers(buildCallable());
Future<..> future = es.submitToKeyOwner(buildCallable(), "Peter");
es.submitToAllMembers(buildCallable(), buildCallback());
es.submitToKeyOwner(buildCallable(), "Peter", buildCallback());

Lock API
// Distributed Reentrant
Lock lock = hz.getLock("myLock");
lock.lock();
try {
// Do something
} finally {
lock.unlock();
}
Distributed Lock

Lock API
Pessimistic Locking (IMap)

Map/Reduce API
Map users = hz.getMap("users");
JobTracker tracker = hz.getJobTracker("default");
KeyValueSource source = KeyValueSource.fromMap(users);
Job job = tracker.newJob(source);
ICompleteFuture future = job.mapper(new MyMapper())
.reducer(new MyReducer())
.submit();
Map result = future.get();

Aggregations API
Map users = hz.getMap("users");
int sum = users.aggregate(
Supplier.all((user) -> user.getSalary()),
Aggregations.longSum()
);

Hazelcast Distributed
Topic Bus
Hazelcast
Topic
Hazelcast
Node 1
Hazelcast
Node 2
Hazelcast
Node 3
MSG
Subscribes
Delivers
Subscribes
Delivers
Distributed Messaging

Queue
Topic (Pub/Sub)
Event Listeners
Ring Buffers
IM Distributed Messaging Features
HD
Cache
Dist.
Compute
Dist.
Message

Queue API
interface com.hazelcast.core.IQueue<E>
extends java.util.concurrent.BlockingQueue
//java.util.concurrent.BlockingQueue implementation
IQueue<Task> queue = hz.getQueue("tasks");
queue.offer(newTask());
queue.offer(newTask(), 500, TimeUnit.MILLISECONDS);
Task task = queue.poll();
Task task = queue.poll(100, TimeUnit.MILLISECONDS);
Task task = queue.take();

Topic API
public class Example implements MessageListener<String> {
public void sendMessage {
ITopic<String> topic = hz.getTopic("topic");
topic.addMessageListener(this);
topic.publish("Hello World");
}
@Override
public void onMessage(Message<String> message) {
System.out.println("Got message: " + message.getMessageObject());
}
}

Data Distribution and Resilience
38

Distributed Maps
Fixed number of partitions (default 271)
Each key falls into a partition
partitionId = hash(keyData)%PARTITION_COUNT
Partition ownerships are reassigned upon membership change
A B C

Data Safety on Node Failure
48

Topologies
Deployment
Architectures

Embedded Mode
Great for microservices,
OEM and ops simplification
IMDG
Application
Java API
IMDG
Application
Java API
IMDG
Application
Java API

Embedded Mode
Embedded model, for example in a J2EE container
Service and storage in the one JVM
Easy for getting started
With three nodes, 1/3rd of the data is local, good read performance
-> This benefit diminishes as you scale up
-> With ten nodes, only 1/10th of the data is local
If the application needs to go offline, so does the data

Client-Server Mode
Great for scale-up or scale-out deployments with cluster
lifecycle decoupled from app servers
Use for non-Java clients
Node.js API
Application
Node.js API
Application
Node.js API
Application
Node.js API
ApplicationJava API
Application
.Net API
Application
C++ API
Application
C++ API
Application
C++ API
Application
C++ API
Application
.Net API
Application
.Net API
Application
.Net API
ApplicationJava API
Application
Java API
Application
IMDG
IMDG IMDG

Client-Server Mode
Follows the traditional Client-Server approach
Clients do not change cluster topology
Allows you to segregate service from storage
Smart clients connect to all cluster members. Operations are routed directly to a
member holding the necessary data.
-> One network hop
Other clients connect to a single cluster member and use it as a proxy to issue
requests.
-> Two network hops if the proxy doesn’t have the data needed

Pushing Into New Language Ecosystems
Hazelcast.org/Plugins
• Fully featured
• Hazelcast supported
• Open Source
• Common Hazelcast Feature Set
• Open Source
• High Performance
• Open Source
• Client and Member APIs
• Scala 2.11 support
• Hazelcast Supported
• Open Source
• Community supported
• Open Source
• Fully Featured
• Open Source
• Industry Leading Performance
• High-Density Memory Store Near Cache
• Hazelcast Supported
• Open Source
Feature Matrix: https://hazelcast.org/clients-languages

Hazelcast IMDG Microservices
Deployment Options
Microservices deployed embedded
with isolated Hazelcast IMDG clusters
Maximum service isolation
Microservices deployed client server
with a shared Hazelcast IMDG cluster
Transition to microservices
MS 1
IMDG IMDG IMDG
MS 1 MS 1
.NET
Client
MS 1
IMDG IMDG IMDG IMDG
.NET
Client
MS 1
Node.js
Client
MS 2
Node.js
Client
MS 2
C++
Client
MS 3
Java
Client
MS 4
Java
Client
MS 4
MS 2
IMDG IMDG IMDG
MS 2 MS 2
MS 3
IMDG IMDG IMDG
MS 3 MS 3

Hazelcast IMDG Microservices
Deployment Options
Microservices deployed client server with isolated Hazelcast cluster per service
Maximum service isolation and non-Java clients
.NET
Client
MS 1
IMDG IMDG IMDG
.NET
Client
MS 1
.NET
Client
MS 1
.NET
Client
MS 1
.NET
Client
MS 1
Python
Client
MS 2
IMDG IMDG IMDG
Python
Client
MS 2
Python
Client
MS 2
Python
Client
MS 2
Python
Client
MS 2

Same Features – Embedded vs Client-Server
// Creating a new Hazelcast node
HazelcastInstance hz = Hazelcast.newHazelcastInstance();
// Getting a Map, Queue, Topic, ...
Map map = hz.getMap("my-map");
Queue queue = hz.getQueue("my-queue");
ITopic topic = hz.getTopic("my-topic");
//Creating a Hazelcast Client
HazelcastInstance client = HazelcastClient.newHazelcastClient();
// Shutting down the node
hz.shutdown();

Hazelcast IMDG – Any Cloud, Anytime
Apache jClouds
PaaS Environment Integrations
Cloud & Cloud Discovery Plugins
Deployment Options
YARN

Hazelcast IMDG WAN
Replication Deployment Options
Independent clusters, sharing selected
data to maintain alignment
One-way or two-way
Choose which data to share, select by type,
can de-select records by attributes
One-way  keep DR site populated
and ready-to-go
Two-way  worldwide operations,
access your nearest data copy
API
Applications
API
Applications
API
Applications
IMDG
IMDG IMDG
IMDG IMDG
IMDG IMDG

Recent Releases & Roadmap
Release Date
Hazelcast IMDG 3.7 August 2016 (Released)
Hazelcast IMDG 3.8 February 2017 (Released)
Hazelcast IMDG 3.9 August 2017
Hazelcast IMDG 4.0 September 2017

New Hazelcast IMDG 3.8 Features
Fast Aggregations
Based on Queries
Make aggregations significantly faster by moving in-built aggregations to be on top of the
query infrastructure of Hazelcast IMDG. Another goal is to expose a simplified
Aggregations API.
User Code Deployment Ability to access and use user classes without having them on the classpath.
Projection for Queries
Provide projection in queries to allow returning specific fields of an entry, not the whole
entry. This will cut the network and serialisation overhead and increase the throughput.
RingBuffer Store
Implementation of the storage mechanism for the RingBuffer, analogous to the existing
QueueStore mechanism. It will also allow users of the ReliableTopic to replay messages
older than the messages in the underlying RingBuffer.
Continuous Query
The previously Enterprise feature Continuous Query Cache becomes open source with
3.8.

Unified Near Cache
Implementation
for IMap and JCache
A technical debt to have just 2 Near-Cache implementations: OnHeapNearCache and
HDNearCache. These 2 implementations should be used by both IMap and JCache as
well as member and client.
High Performance Near Cache Several Improvements on Near Cache including pre-loading near cache.
Eventually Consistent
Near Cache
A guarantee of delivery of cache invalidations to the near cache.
HyperLogLog
Implementation of the HyperLogLog data structure on top of Hazelcast IMDG. It is a
probabilistic structure used to estimate cardinality.
Scheduled Executor Service Distributed version of java.util.concurrent.ScheduledExecutorService.
Cluster Quorum
for Queue and Lock
Quorum support for Hazelcast IMDG Queue and Lock.

New Hazelcast IMDG 3.8 Enterprise Features
Rolling Member Upgrades
for Minor Releases
Extending current rolling upgrade capability of Hazelcast IMDG (client rolling
upgradeability, patch version rolling member upgrades) to allow heterogeneous versions of
Hazelcast IMDG members to be rolling upgraded without service interruption for minor
version changes.
Copying HRS Data
from a Source to a Target Cluster
Ability to copy the Hot Restart store files from a source environment to a target
environment (for example, product to test environment). This feature also applies to
running sources.
One-Off WAN Sync with
Dynamically Added Endpoint
Ability to copy all Maps’ content to a target cluster dynamically in runtime.
SSL Performance Improvements
(Java)
Large performance increase in SSL when using the Java client.
LDAP Integration for
Management Center
Authentication and authorizarion with LDAP in Management Center.
Many Management Center
Enhancements
More metrics, stats, and improved usability and monitoring.

New Hazelcast IMDG 3.8 Clients Features
Mutual Auth with TLS
Certificates
Allow using client certificates to identify the client to the server.
Simulator Integration
for Hazelcast .NET Client
Integration of the .NET client into Hazelcast Simulator.
Node.js Client Enhancements RingBuffer, Topic, and Near Cache Support for Node.js client.
SSL Support for Node.js Client
SSL support for Hazelcast Node.js Client to secure the connection between the client and
the members.
Near Cache Support
for C++ Client
Configurable near cache support for IMap in the Hazelcast C++ client.
AWS Discovery for C++ Client AWS cluster discovery implementation for Hazelcast C++ Client.

New Hazelcast IMDG 3.8 Cloud & Plugins Features
Pivotal® CloudFoundry
Integration
Hazelcast IMDG on Pivotal CloudFoundry as a Tile.
IBM DynaCache API Support
A WebSphere DynamicCache provider, which could be used either by traditional
WebSphere or WebSphere Liberty Profile applications.
Discovery SPI based AWS
Module
Discovery SPI compatible hazelcast-aws module. AWS users would take advantage of
ZONE_AWARE (availability zone aware partition groups) without using Apache jclouds.
Striim Hot Cache Adapter
HotCache functionality with Striim based on Change Data Capture ("CDC") of underlying
database updates.
Hibernate 5.2 Support Improvements in distributed L2 cache for Hibernate to support Hibernate 5.2.

Hazelcast 3.9 Roadmap
August 2017

3.9 Features
Near Cache: Key Store-by-
Reference Option
Key store-by-reference option for IMap and Hazelcast JCache Near Cache.
Dynamic Creation of Specificly
Configured Distributed Objects
Ability to define new data structures with custom configuration on the fly.
Gigantic Cache Migration
Enhancements
Improvements in partition migration process to allow better gigantic cache migrations.
Lazy Initiation for Java Client An async client factory to connect lazily and in a non-blocking manner.
Client Support for User Code
Deployment
Dynamic Classloading from clients for User Code Deployment.
Query Async API Async query methods on the IMap

3.9 – Security Features
Mutual TLS Auth Java Client Allow a member to authenticate a client using a certificate installed in the client
Mutual TLS Auth C# Client Allow a member to authenticate a client using a certificate installed in the client
Management Center TLS TLS from members to Man Center. TLS from browser. TLS for REST endpoint
TLS for REST endpoint on
Members
General Security Hardening
Implement things like password blacklisting, password complexity requirements, toggling off
of non-secure mechanisms when secure version is enabled and so on
Fast SSL/TLS Make SSL/TLS almost as fast as unencrypted.

Fast SSL/TLS

New Hazelcast IMDG 3.9 Enterprise Features
Dynamic Addition of WAN
Endpoints
Ability to add WAN Targets to a running cluster.
NearCache Stats in Management
Center
Provision of showing data inside Near-Cache of client or member, similar to IMap/Cache in
Management Center.
Search Indexes in HD Memory Support for sorted and unsorted indexes in Hazelcast HD Memory Store.

New Hazelcast IMDG 3.9 Clients Features
Simulator Integrations of
C++, Python, and Node.js Clients
Integration of C++, Python, and Node.js clients into Hazelcast Simulator.
SSL Performance Improvements
for .NET Client
Large performance increase in SSL when using the .NET Client.
Projections for .NET Client Add projections (returning attributes rather than full values) to .NET.
Paging Predicate for .NET Client Support for paging predicates in Hazelcast .NET Client.
ExecutorService for C++ Client Ability to use the distributed ExecutorService from Hazelcast C++ Client.
Near Cache for C++ Client Add near cache to C++ client
TLS for C++ Client Add TLS encryption for C++ Clients communicating with members

New Hazelcast IMDG 3.9 Cloud & Plugins Features
Google Cloud Platform Integration SPI Plugin for GCP for Cloud Discovery with a support for partition groups.
AWS support for C++ Client We have comprehensive cloud support for Java. Adding AWS to C++.
Stats for Hibernate
LocalRegionCache
Ability to provide statistics for Hibernate LocalRegionCache.
Web Sessions for WebSphere
Liberty
Web sessions replication plugin for WebSphere Liberty.

Java 8 Language Level
Lift the language level for Hazelcast members and their API to Java 8. Add a new Java 8
client. Continue to maintain the Java 6 compatible client. This will allow us to take advantage
of Java 8 language features.
Java 9 Modularisation
Java 9 modularisation for Hazelcast IMDG, which introduces Jigsaw - a new modular
systems with a strict enforcement of module boundaries.
Proper Separation of Public and
Private APIs
Re-design of the whole private/public API to keep as much private as possible.
Public and Stable SPI
Make SPI a second public and stable API. This work includes many refactorings, client
protocol enhancements, documentation efforts, and reference implementations.
EntryProcessor Contract
Formalisation
Optimization of the EntryProcessor which would bring the IMap behaviour inline with the
JCache behaviour.
Unification of Client / Member
Behaviour in Exceptional States
Equalization of exceptions in client-side and member-side so that clients can throw the same
exceptions as server whenever possible. This work also includes a documentation effort on
exceptional cases for each method.

What’s Hazelcast Jet?
• General purpose distributed data processing
framework
• Based on Direct Acyclic Graph to model data
flow
• Built on top of Hazelcast
• Comparable to Apache Spark or Apache Flink
8
7

Service Offerings
Hazelcast (Apache Licensed)
• Professional Subscription – 24x7 support*
Hazelcast Enterprise Support
• Available with Hazelcast Enterprise software subscription - 24x7 support*
Additional Services
• Development Support Subscription – 8x5 support*
• Simulator TCK
• Training
• Expert Consulting
• Development Partner Program
* All subscriptions include Management Center

Support Subscriptions
What’s Included
100% SUCCESS RATE ON CUSTOMER ISSUES:
“As usual, the response was timely beyond
expectations, and very good technical content
returned. Exemplary support, hard to find in
any company…”
- Fortune 100 Financial Services Customer
ENTERPRISE HD ENTERPRISE PROFESSIONAL OPEN SOURCE
SUPPORT WINDOW 24/7 24/7 24/7
RESPONSE TIME FOR CRITIAL ISSUES 1 Hour 1 Hour 2 Hours
SUPPORTED SOFTWARE
Hazelcast &
Hazelcast Enterprise
Hazelcast &
Hazelcast Enterprise
Hazelcast
SUPPORT CONTACTS 4 4 2
SUPPORT CHANNELS Email, IM & Phone Email, IM & Phone Email, IM & Phone
PATCH LEVEL FIXES
REMOTE MEETINGS (via GoToMeeting)
CODE REVIEW (with a Senior Solutions Architect) 2 Hours 2 Hours 2 Hours
QUARTERLY REVIEW OF FEATURE REQUES*
QUARTERLY REVIEW OF HAZELCAST ROADMAP*

© 2016 Hazelcast Inc. Confidential & Proprietary
9
3
Best In Class Support
Support from the Engineers who wrote
the code
SLA Driven – 100% attainment of
support response time
Follow the Sun
Portal, Email and Phone access
Go Red, Go Green. Reproduction of
issues on Simulator. Proof of fix on
Simulator.
Periodic Technical Reviews
Meet your production schedule and
corporate compliance requirements
Ensure the success of your
development team with training and
best practices

9
4
Hazelcast Support Coverage
India
Turkey
London
U.S.

Support Testimonials

Release Lifecycle
• Regular Feature release each 4-5 months, e.g. 3.3, 3.4, 3.5
• Maintenance release approximately each month with bug fixes based
on the current feature release, e.g. 3.4.1
• For older versions, patch releases made available to fix issues
• Release End of Life per support contract

Distributed caching-computing v3.8

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Distributed caching-computing v3.8

Semelhante a Distributed caching-computing v3.8 (20)

Último

Último (20)

Distributed caching-computing v3.8