Building Scalable Microservices for Java using Helidon and Coherence CE

Was great to listen to Aleksander and Dimitri talk about “Scalable Microservices for Java using Helidon and Coherence CE” in the Oracle Developer Live – Java Innovations online session a couple of days ago.

A lot of great information about Helidon and Coherence and how to combine them to create Microservices based applications.

The YouTube replay is below plus a few useful links to useful information!



Posted in Presentations | Tagged , , , | Leave a comment

Open Source Coherence VisualVM Plugin v1.0.1 Released

A new and updated version of the Open Source Coherence VisualVM Plugin has just been released!

This new release contains a number of new features (as well as a few bug fixes) which will make using the Plugin much easier.

You can view the release notes here or read on to find out more.

Options Panel

We have added a new Options panel to allow easier setting of various functionality rather than having to specify properties on command line. Once the Plugin is installed, you can access via VisualVM->Preferences on Mac or Tools->Options on Windows or Linux.

VisualVM Options

Taking Multiple Thread Dumps

You have previously been able to take thread dumps by right-clicking on a member on the Members tab, but now you can also choose Generate Multiple Thread Dumps. This is useful especially in a support situation or you just want to understand what the thread are doing.

Taking Multiple Thread Dumps

Saving and Copying Thread Dumps

Going hand in had with the above, we have enhanced the thread dump dialog to include additional node and cluster information as well as give you the ability to save or copy the contents to the clipboard.

Experimental Features

We have added some “experimental” features, that can be enabled in the new options panel, that may be included as standard features down the track. Please feel free to provide feedback on any of these below:

  • Added experimental tab to display Coherence Topics information
  • Added experimental option to issue thread dump across all members
  • Added experimental “Cluster Snapshot” Tab which gives a text based snapshot of the cluster which you could cut/paste to assist in diagnosis of issues.

Installing the Update

If you already have the plugin installed, then within VisualVM Choose Tools -> Plugins from the main menu and click on Check for Updates if it doesn’t already show in the Updates tab.

If this is your first time using the Coherence VisualVM Plugin, see the GitHub Page for instructions to install.


Posted in New Features | Tagged , , , , | Leave a comment

Monitoring Coherence in Docker with Grafana

Coherence provides the ability to expose Metrics via HTTP in a number of formats, Prometheus being the default. With this feature it is very easy to monitor a Coherence using Grafana.

In this post I will show you how to run the Coherence Docker image and view metrics via Grafana using docker-compose to start the following images:

  • Coherence Community Edition (CE) version 20.12
  • Grafana
  • Prometheus

The Docker images will expose the following ports:

  • Coherence
    • 1408 – gRPC Proxy port
    • 9612 – Coherence metrics endpoint to be scraped by Prometheus
    • 20000 – Coherence*Extend port
    • 30000 – Management over REST port
  • Grafana
    • 3000 – Grafana UI
  • Prometheus
    • 9090 – Prometheus UI

For more information please see

What will you need?

  • Docker Desktop for Mac or the equivalent Docker environment for you O/S.
  • docker-compose
  • Git

Clone the example repository

git clone
cd coherence-docker-metrics

Download the Grafana Dashboards

For Linux or Mac run the following to download the dashboards from the Coherence Operator GithHub page.

cd coherence-docker-metrics/grafana
cd ..

For Windows:

  1. Clone the Coherence Operator repository –
  2. Copy all the *.json files from coherence-operator\dashboards\grafana to the directory grafana\dashboards under cloned coherence-docker-metrics repository.

Start the Docker Containers

from the coherence-docker-metrics directory run:

docker-compose up -d
Creating coherence-docker-metrics_grafana_1    ... done
Creating coherence-docker-metrics_coherence_1  ... done
Creating coherence-docker-metrics_prometheus_1 ... done

docker ps --format '{{ .ID }}\t{{.Image}}\t{{ .Names }}'

8067f3e38f61	grafana/grafana	coherence-docker-metrics_grafana_1
7bef8a89862f	prom/prometheus	coherence-docker-metrics_prometheus_1
07aeb39eb036	oraclecoherence/coherence-ce:20.12	coherence-docker-metrics_coherence_1

Note: I have included abbreviated output above but you can use docker ps to show the full output.

Access Grafana

Access the Grafana Dashboard using the following URL: http://localhost:3000/d/coh-main/coherence-dashboard-main

Default username/password is admin/admin

Main Dashboard

You can now explore the metrics exposes via Coherence.

How it Works

If you take a look at the docker-compose.yaml file you will see a number of sections for each of the Docker Images.


The Coherence image exposes metrics via setting the coherence.metrics.http.enabled=true and ensures that the default metrics port, 9612 is exposed amongst other ports 30000 for management over REST, 20000 for Coherence*Extend and 1408 for gRPC proxy.

  image: oraclecoherence/coherence-ce:20.12
    - coherence.member=storage
    - coherence.machine=localhost
    - coherence.metrics.http.enabled=true
    - 30000:30000
    - 20000:10000
    - 1408:1408
    - 9612:9612


The Prometheus image includes the /prometheus/prometheus.yaml file and exposes the 9090 port.

  image: prom/prometheus
    - ./prometheus/prometheus.yaml:/etc/prometheus/prometheus.yaml
    - '--config.file=/etc/prometheus/prometheus.yaml'
    - 9090:9090

The prometheus.yaml file contains the following to scrape the default Coherence metrics port every 15s:

  scrape_interval: 15s

  - job_name: 'Prometheus'
      - targets: ["localhost:9090"]
  - job_name: 'coherence_cluster'
      - targets: [""]


Finally, the Grafana image creates a Prometheus datasource and loads the Dashboards:

  image: grafana/grafana
    - ./grafana/grafana.ini:/etc/grafana/grafana.ini
    - ./grafana/datasources.yaml:/etc/grafana/provisioning/datasources/datasources.yaml
    - ./grafana/dashboards.yaml:/etc/grafana/provisioning/dashboards/dashboards.yaml
    - ./grafana/dashboards:/etc/grafana/provisioning/dashboards/dashboards
    - 3000:3000


You can see from the above that it is very easy to expose and captures the metrics from a Coherence Cluster. For more information see the following:


Posted in Examples | Tagged , , , , , , | Leave a comment

Access Coherence Data using GraphQL

Helidon version 2.2.0 has just been released and supports the MicroProfile GraphQL specification from the Eclipse Foundation. Using Coherence’s MicroProfile integration with Helidon, it is now easy to access Coherence data via a GraphQL endpoint.

Having worked on updating Helidon to support the MicroProfile GraphQL Spec last year, I’m looking forward over the next couple of months to share tips, tricks and examples of how this works in detail.

Please take a look at my Medium Post where where I take you through updating the Coherence To Do example with a GraphQL endpoint.



Posted in Related Posts | Tagged , , , , , | Leave a comment

Coherence Community Edition 20.12 Released

Coherence Community Edition (CE) 20.12 has just been released. The full Medium post can be found here, but I have included some summary information below.

This release is the second major 6 monthly release of Coherence CE and includes some exciting new features and capabilities:

  • Bootstrap API – A new simple API for configuring and starting Coherence cluster members – see the documentation
  • GraphQL Support – Along with Helidon 2.2.0, you can expose GraphQL endpoints to access and mutate your Coherence Data – see the Helidon blog for more information. Look out for a Coherence example early in the new year
  • Parallel Recovery for Coherence Persistence – A great enhancement to the Persistence feature to decrease the startup and recovery times for Coherence clusters – see the documentation
  • Micrometer Metrics – Support for Micrometer metrics – see the documentation

Have a safe and happy holiday break and see you in the new year!

Posted in Uncategorized | Tagged , , , | Leave a comment

Open Source Coherence VisualVM Plugin Released!

We are excited to announce that the open source Coherence VisualVM Plugin has been released and is now available to install directly from VisualVM 2.0.4 and higher.

The Plugin can connect to and display data for both Community and Commercial Coherence Clusters.

To install the Plugin it’s as simple as starting up VisualVM, going to Tools, Plugins, selecting the VisuaVM-Coherence Plugin from the Available Plugins tab and clicking Install.

Coherence VisualVM Plugin Install

Useful links:


Posted in News | Tagged , , , | Leave a comment

Presentation: Patterns of Domain-Driven Design with In-Memory Data Grids

A great presentation from Coherence Product Manager Randy Stafford, at the “In-Memory Computing Summit”. In his presentation he covers:

  • Domain Driven Design – DDD
  • In-Memory Data Grids – IMDG’s
  • Patterns of DDD with IMDG’s
  • Cool new stuff with with Oracle Coherence

The recording and slides can be found here:


Posted in Presentations | Tagged , , , , , | Leave a comment

Hello, Coherence Community Edition, Part 2: Building the client

The second part of Aleks Seovic’s article in Java Magazine has now been published!

In part 2, Aleks walks through building React and JavaFX front ends to integrate with the REST API that was developed in part 1.

The React client uses REST and the JavaFX client uses our new gRPC based Java client and gRPC proxy server built upon Helidon’s gPRC Server. The new gRPC support provides a modern connection capability for Coherence clients. At the moment there is only a Java based gRPC client but there are plans to provide gRPC support for a number of languages. (watch this space!).

The article is available here – and is a great read!

The full example is available on GithHub –


Posted in Examples | Tagged , , , , , , | Leave a comment

Coherence JavaScript Client Now Available for Community Edition

Exciting news overnight that the Coherence JavaScript client is now available for Coherence Community Edition 20.06.1!

Previously, the only way to access Coherence from a Node.js application was via REST, but now you have the capability to access Coherence caches via a native JS API with familiar Map interface along with the capabilities of querying, aggregations, in-place processing and events.

The JavaScript client communicates using gRPC ( to a gRPC enabled Proxy server on a the Coherence cluster. This is the second client (After Java gRPC client) to take advantage of our native support for gRPC and surely won’t be the last.

It’s as easy as adding the dependency to your package.json file:

"dependencies": {
    "@oracle/coherence": "^1.0.0",

Starting a gRPC enabled Coherence Docker image:

docker run -d -p 1408:1408 oraclecoherence/coherence-ce:20.06.1

and finally running your code:

const { Session } = require('@oracle/coherence')
let session = new Session()
let map = session.getMap('Test')
setImmediate(async () => {
  console.log("Map size is " + (await map.size))
  console.log("Inserting entry (key=1, value=One)")
  await map.set(1, "One")
  console.log("Map entry is " + (await map.get(1)))
  console.log("Deleting entry (key=1)")
  await map.delete(1)
  console.log("Map size is " + (await map.size))
  await session.close()

See here for Randy Stafford’s full post on the release on Medium.



Posted in News | Tagged , , , | Leave a comment

Recording Available: Managing State in Elastic Microservices

If you didn’t get a chance to attend Coherence Architect Aleks Seovic’s talk on “Managing State in Elastic Microservices”, then the recording is now available on YouTube. This was the September 2020 Jakarta Tech Talks session.

In this talk, Aleks runs through the Helidon Sock-Shop Demo, which is the modern day microservices equivalent of the old “Pet Store Demo”. The demo showcases Coherence Community Edition (CE) and the Helidon Microservices framework and how to write modern and scalable microservices applications.

I particularly liked the part where he scaled his Coherence cluster to 1TB running on Kuberenetes!

Scaled Coherence Cluster in Grafana

Useful Links:


Posted in Presentations | Tagged , , , , | Leave a comment