This is the only conference focused exclusively on the in-memory computing space, and has been running annually since 2015.  It is fitting for Coherence to be represented there.

Domain-Driven Design (DDD) has rightfully earned staying power as a software architecture style.  Strictly speaking, its essence is abstract from, and upstream of, any particular implementation.  But at some point the rubber must meet the road.  Domain object classes must be coded, and their instances persisted somehow.

In-Memory Data Grids (IMDGs) typically incorporate a key-value data model.  Thus the question arises, "how do I impose my domain model onto an IMDG?" In other words, assuming Maps are the primary abstraction available for storing data in an IMDG, what set of Maps should I have for storing my domain model?  How should I handle inter-object relationships?  What about transactions, especially those modifying multiple domain objects at a time?

This talk digs into those questions, and provides answers distilled over years of experience using IMDGs to manage domain objects in DDD-based applications.  The distilled answers are essentially a set of patterns for using DDD with IMDGs.  The talk also touches on how new capabilities, like GraphQL, are changing what is possible when using DDD with IMDGs.

Architects and developers intending to use DDD with IMDGs in their enterprise applications will benefit from the experience collected and distilled into these patterns, as they contemplate how best to resolve forces in their particular contexts.

A recording of the talk is available at https://www.imcsummit.org/2020/virtual/session/patterns-domain-driven-design-memory-data-grids.

      

Coherence JavaScript Client offers the familiar Map interface to get and set keyed values, and a whole lot more:

• querying Map values by criteria
• aggregating values in a Map
• in-place processing of Map entries
• listening for Map events

Here’s a quick code example showing the basics:

When run, it produces:

Here’s another example, showing queries over JSON objects:

Using a filter we can limit the result set returned by the map:

Coherence JavaScript Client uses the gRPC proxy in the open-source Coherence Community Edition to communicate with a remote Coherence cluster from a Node.js process for Map operations and events. The remote Coherence cluster is capable of storing terabytes of data persistently, and handling thousands of operations per second. Data is sharded automatically in the cluster, which can be dynamically scaled and operated with Kubernetes.

Coherence JavaScript Client is the second native-language client (after Java) to use the new gRPC proxy in Coherence, with many more to come. New implementations of the .NET and C++ clients currently based on the Coherence*Extend proxy are in the pipeline, as are Python and mobile platform clients.

If you have a Node.js application needing highly scalable and reliable key-value data management, including querying and eventing, then have a look at Coherence JavaScript Client for Coherence Community Edition. More information may be found at the following links:

• https://www.npmjs.com/package/@oracle/coherence
• https://coherence.community

      

Scaling stateless services is easy, but scaling their stateful data stores, not so much. This is true whether you are using an “old fashioned" relational database, or one of the popular, “modern" KV data stores, such as MongoDB or Redis.

In this presentation we will discuss some of the issues with state management in elastic microservices today, and look into how Oracle Coherence, with its Helidon and Eclipse MicroProfile integration, provides a better alternative you can use tomorrow.

This will be a technical presentation by an architect who has deep technical understanding of microservices and data grid technologies, and real-world experience building and deploying mission-critical applications.  Aleks' talk will include a demo showing how Java microservices can be easily scaled, including flexible scaling of the data store used by the microservices, using an example you can evaluate yourself following his talk.  The example is built with Helidon 2.0 and Coherence Community Edition  announced in June.  Both Helidon and Coherence can be used to build and evolve microservices applications, either on-premises or in the cloud, so the content will be relevant and thought-provoking for Coherence users.  Register today! 

      

The presentation and webinar recording from the launch event are now available for viewing.

The Coherence team invites you to check out these materials, and communicate with us directly via Slack and Twitter.

      

Coherence Community Edition is licensed under the Open Source Initiative’s Universal Permissive License, Version 1.0, and is hosted on GitHub: https://github.com/oracle/coherence.

Coherence Community Edition provides a reliable and scalable platform for state management and polyglot processing on the data grid.   Integration with Helidon, GraalVM, Oracle Database and Database Cloud services and other technologies makes Coherence Community Edition an essential component of a modern cloud-native microservices architecture.

Coherence Community Edition contains all In-Memory Data Grid functionality necessary to write modern cloud microservices applications, including:

• fault-tolerant automatic sharding
• scalable caching, querying, aggregation, transactions, in-place processing
• polyglot programming on the grid side with GraalVM
• persistence and data source integration
• eventing, messaging, and streaming
• a comprehensive security model
• unlimited clients in polyglot languages and over REST
• Docker and Kubernetes support, with Kibana and Prometheus dashboards

Oracle continues to offer commercial Oracle Coherence Enterprise Edition and Oracle Coherence Grid Edition entitling even more powerful features for the most demanding deployments, with Coherence Community Edition at their core.

 “Coherence came to leadership through innovation, reliability, and close relationships with developers.  With Coherence Community Edition, we are delighted to share the benefits of the leading In-Memory Data Grid with the broad community of developers who use open-source technology for ambitious enterprise applications,“ said Coherence co-founder and Oracle Product Development Vice President Alex Gleyzer.

“Oracle open-sourcing Coherence Community Edition is the most exciting news.  That is going to make a huge difference for us,” said Union Pacific Railroad Associate Vice President and Distinguished Technologist Arun Giri. “Now there’s a bigger community, so it’s a huge win.”

This initial availability of Coherence Community Edition includes two releases:

1. 14.1.1.0.1, the core of all Coherence 14.1.1 editions as of patch set update 1; and
2. 20.06, the June 2020 interim release of upcoming 14.1.2 features.

Upcoming 14.1.2 features available in the 20.06 interim release include:

• a gRPC proxy into Coherence clusters, on which polyglot clients are based
• a Java client of the gRPC proxy, exposing the full Coherence client API
• Helidon MP integration, with CDI, Metrics, and Config implementations

Concurrently with this initial availability of Coherence Community Edition, Oracle is also making available in open source a comprehensive microservices demonstration application based on Coherence Community Edition and Helidon 2.0.  This microservices demo app, named Helidon Sock Shop, derives from https://github.com/microservices-demo/microservices-demo, but has been re-implemented to leverage Coherence Community Edition for all state management and messaging, and Helidon 2.0 as the microservices framework, gaining significant improvements in design simplicity.  The Helidon Sock Shop demo is available at https://github.com/helidon-sockshop.

The Coherence product development team is proud to launch Coherence Community Edition.  We are excited to make the leading In-Memory Data Grid’s proven out-of-the-box reliability and scalability available to the broad community of developers using open-source software to develop Java and polyglot microservices applications.

We invite you to explore the Coherence Community Edition website https://coherence.community, watch animations of how the product works, follow the quick start guide, and give Coherence a try!
 

      

We will also be introducing Helidon 2.0.  Helidon provides a set of Java libraries in open source for developing lightweight microservices, leveraging technologies such as GraalVM Native Image and Microprofile.  Helidon 2.0 is the latest release which has been under development for months.   The Helidon team will be there to highlight its new features and capabilities.  We will also show how Helidon 2.0, and GraalVM, can be used together with Coherence CE to deliver innovative microservices architectures with built-in scalability, reliability and performance.

Please register now for one of these webinars, at the time that works for you, at:

• APAC Webinar – June 24th late evening US Time
• NAS, EMEA, LAD Webinar on June 25th a.m. US Time

Thanks for your interest!

      

In order to use the Coherence integration with OpenTracing, the following dependencies (in maven coordinate format) need to be satisfied:

• OpenTracing API artifacts
  • io.opentracing:opentracing-api:0.3{2,3}.0
  • io.opentracing:opentracing-util: 0.3{2,3}.0
  • io.opentracing:opentracing-noop: 0.3{2,3}.0
• OpenTracing TracerResolver: io.opentracing.contrib:opentracing-tracerresolver:0.18

The API artifact requirement is straightforward; however, the tracerresolver dependency does warrant some discussion.  The tracerresolver library allows the discovery of OpenTracing-compliant implementations on the class path using Java’s ServiceLoaderfacility.  This decouples Coherence from the instantiation and configuration of a particular runtime and allows the developer to use any compliant runtime they wish.  At the moment, Jaeger is the only OpenTracing-compliant runtime that includes a TracerResolver implementation; however, the TracerResolver API is simple enough for a developer to be able to write an implementation to bootstrap the tracing implementation of choice for use with Coherence.

That said, if your shop is using or plans to use Jaeger, then you can save some time and include io.jaegertracing:jaeger-client:1.1.0[1]  as your project dependency as its transitive dependencies already include the required OpenTracing API artifacts mentioned above.

The following operations are traced:

• NamedCache operations against partitioned caches
• Events generated for MapListener and/or EventInterceptor implementations
• CacheStore operations
• Backup & Persistence operations

All tracing spans generated by Coherence will include common metadata, such as:

• The member ID
• The originating member ID, if the operation was dispatched to another member for processing
• The thread name
• The component name, such as PartitionedCache, ReadWriteBackingMap or transport

When reviewing the spans generated by Coherence, you may notice that some operations may appear with different suffixes (e.g., Invoke.request, Invoke.dispatch, and/or Invoke.process).  These suffixes represent the different stages an operation goes through in order to be serviced.

• request – a NamedCache operation has been submitted to other member(s) of the cluster
• dispatch – the request has been received by a recipient and has either been added to a thread pool for execution (if present/applicable) or executed within this span. 

process – the receiver of the request executed the NamedCache operation

Like most features in Coherence, there are multiple ways to configure the OpenTracing integration.  All methods revolve around configuring the tracing sampling ratio.  The sampling ratio can be expressed as one of three valid configuration states:

• -1 – This value will disable tracing (this is the default).
• 0 – This value means Coherence will not initiate tracing spans without an already active span, so developers must start a tracing span prior to invoking the Coherence operation of interest.
• 0.01-1.0 – This range is the percentage of spans that will be captured.  For instance, a value of 0.1 will cause 10% of the tracing spans to be sampled, while a value of 1.0 will result in all spans being collected.

We’ve added a new element called tracing-config (please see the schema for details on element ordering) that allows the configuration of the tracing sampling ratio:

    <?xml version='1.0'?>
    <coherence xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"               xmlns="http://xmlns.oracle.com/coherence/coherence-operational-config"               xsi:schemaLocation="http://xmlns.oracle.com/coherence/coherence-operational-config   coherence-operational-config.xsd"
               xml-override="common/tangosol-coherence-override.xml">
      <tracing-config>
        <sampling-ratio>1</sampling-ratio>
      </tracing-config>
    </coherence>

If using an override file isn’t desirable, it is possible to configure the OpenTracing integration using a system property named coherence.tracing.ratio.  For example:

    ${JAVA_HOME}/bin/java ${JAVA_OPTS} -Djava.net.preferIPv4Stack=true \
            -Dcoherence.tracing.ratio=1 \
            -cp ${COH_HOME}/lib/coherence.jar \
            com.tangosol.net.CacheFactory

The tracing sampling ratio can be configured at the cluster, role, or member level with JMX.

To change the sampling ratio at a cluster level, use the configureTracing(String, Float) operation exposed on the ClusterMBean.  The String argument specifies the role of the members to be updated.  If null or a zero-length string, then the configuration change will be applied to all cluster members.  The float argument represents the desired tracing ratio.

To view or change the tracing ratio on a per-member basis, see the mutable property, TracingSamplingRatio, on the ClusterNodeMBean.

If a REST style of cluster management is required, it is also possible to configure the tracing ratio using Management over REST.

To change the sampling ratio at a cluster level, issue a POST to /management/coherence/cluster/configureTracing resource.  This resource is functionality equivalent to the configureTracing(String,Float) operation on the ClusterMBean.  The body should be a JSON object with the keys role and tracingRatio.  Here’s an example using curl:

where, because role is null (or a zero-length string), the configuration change will be applied to all members.  If, for example, the following was sent:

then the tracing configuration will be applied to only those members with the matching role of storage.

In order to make per-member changes, use the /management/coherence/cluster/members/{memberIdentifier} resource where {memberIdentifier} is the member ID.  How this resource behaves depends on the HTTP verb.  For example, sending a GET, like:

will result in all of the readable properties and their values being returned for that specific member.

Sending a POST to this resource indicates the intent to update the property with a new value.  The body should be a JSON object with the key being the name of the property and its value representing the updated configuration value.  Here’s an example updating the sampling ratio for member 1:

Let’s prove that the feature works.   We’ll do this by starting a Jaeger instance to capture and visualize the spans generated by Coherence.  We’ll then start two storage-enabled cache servers and one console-based member (to interact with the cache); all with tracing enabled via the command line.  This is the minimum effort required to demonstrate this feature. 

We’re going to use a Docker container to run the Jaeger instance. Fortunately, the Jaeger folks have made this easy - we can simply run:

We can verify Jaeger is working by accessing http://localhost:16686 with a browser:

With Jaeger available, let’s stand up a Coherence cluster containing two storage-enabled members and one member as the console.

Here is the command used to start the storage enabled members:

The command for the console member isn’t much different outside of the omission of coherence.distributed.localstorage and a different main class:

In all cases, note that the tracing ratio is configured using the coherence.tracing.ratio system property with a value of 1; meaning all tracing spans will be captured and that we’ve defined the JAEGER_SERVICE_NAME and pointed JAEGER_ENDPOINT to the default tracing endpoint when using the Jaeger all-in-one development container.

If we start the cluster/console now using these commands, once stable, it should be possible to see Coherence in the list of Services enumerated by the Jaeger UI (you may need to refresh the browser in order for the change to be visible):

From the console we previously started, let’s see if we can generate some spans:

Switch back to the Jaeger UI, and let’s look at what was captured:

Here’s our PUT!    The operation itself generated four additional spans.  Let’s take a closer look:

While it’s possible to start a local Jaeger instance followed by starting a Coherence cluster and showing what tracing spans are generated, that doesn’t make for a very interesting demo.  So we decided to take the existing Coherence Demo application, add database support, and then ensure all JAX-RS and database operations are traced, in addition to Coherence operations.

The following represents a high-level view of the changes we plan to make to the Coherence Demo application in order to demonstrate how Coherence OpenTracing fits into a larger, more complex application.   We’ll demonstrate how we were able to generate tracing spans for both the JAX-RS and database layers of the application.  Lastly, we’ll show-off the dynamic configuration, of both cluster-wide and per-member tracing by using Coherence Management over REST.   

As there are many changes being made to demonstrate this feature as thoroughly as possible, we decided it will be best to break this discussion up over a series of blogs starting with the JAX-RS modifications.  From there, we’ll follow up roughly weekly with additional entries until we have the demo in the desired state.  

So, check back next week as we start on a short, but interesting journey to “tracify” the coherence-demo application, which we hope, after reviewing, will help you add tracing to your own Coherence applications, to take advantage of the insights this new feature can offer.

      

Each topic can be independently configured, enabling selecting appropriate Quality of Service (QoS) of in-memory, journaled or persistent for topic content, setting maximum storage size used by a topic within the data grid,  and numerous other configurable parameters.  Grid-side content filtering and transformation enable optimizing data transmission from the data grid to Topic subscriber clients.

Publish/Subscribe messaging enables the building of data pipelines between loosely coupled producers and consumers. One or more publishers can publish streams of values to a topic. One to many subscribers consume the stream of values from the topic. The topic values are spread evenly across all Oracle Coherence data servers, enabling high throughput processing in a distributed and fault tolerant manner. Each direct subscriber to a topic receives all values published to the topic.

Figure 1: Broadcast messaging from one publisher to multiple direct topic subscribers

One or more Subscribers subscribe to a Topic’s subscriber group. Each value of the subscriber group is consumed by only one subscriber group member, enabling parallel processing of those values. Thus, each subscriber group in effect behaves like a queue for the processing of its data.

Figure 2: Parallel consumption of Topic subscriber group values by multiple Subscriber Group Members.

Below is a Hello World publish/subscribe example followed with a modification to illustrate consuming from a subscriber group.

Minimal configuration file to define topic example-topic.

File: coherence-cache-config.xml
<?xml version="1.0"?>
<cache-config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns="http://xmlns.oracle.com/coherence/coherence-cache-config"
              xsi:schemaLocation="http://xmlns.oracle.com/coherence/coherence-cache-config coherence-cache-config.xsd">
  <topic-scheme-mapping>
    <topic-mapping>
      <topic-name>example-topic</topic-name>
      <scheme-name>topic-server</scheme-name>
    </topic-mapping>
  </topic-scheme-mapping>
  <caching-schemes>
    <!-- partitioned topic scheme for servers -->
    <paged-topic-scheme>
      <scheme-name>topic-server</scheme-name>
      <service-name>PartitionedTopic</service-name>
      <local-storage system-property="coherence.distributed.localstorage">true</local-storage>
      <autostart>true</autostart>
    </paged-topic-scheme>
  </caching-schemes>
</cache-config>
 

File: HelloWorldPublisher.java

import com.tangosol.net.Session;
import com.tangosol.net.topic.NamedTopic;
import com.tangosol.net.topic.Publisher;

public class HelloWorldPublisher
    {
    static public void main(String[] args) throws Exception
        {
        try (Session                      session      = Session.create();
             NamedTopic<String> topic         = session.getTopic("example-topic");
             Publisher<String>       publisher = topic.createPublisher())
            {
            publisher.send("hello world").join();
            System.out.println("Published to topic " + topic.getName());
            }
        }
    }
 

Topic direct subscriber client.

File: HelloWorldSubscriber.java

import com.tangosol.net.Session;
import com.tangosol.net.topic.NamedTopic;
import com.tangosol.net.topic.Subscriber;
import com.tangosol.net.topic.Subscriber.Element;

public class HelloWorldSubscriber
    {
    static public void main(String[] args) throws Exception
        {
        try (Session                      session       = Session.create();
             NamedTopic<String> topic          = session.getTopic("example-topic");
             Subscriber<String>    subscriber = topic.createSubscriber())
            { 
            System.out.println("HelloWorldSubscriber for topic " + topic.getName() +
                " waiting to receive a value ...");
            Element<String> e = subscriber.receive().get();
            System.out.println("Received: " +  e.getValue());
            }
        }
    }
 

1. Download coherence 14.1.1 and install. Set COHERENCE_HOME environment variable to installation directory.
2. Make a directory to contain the HelloWorld sample files.
   1. Create source file by copy and paste for each listed file.
   2. mkdir classes
   3. cp coherence-cache-config.xml classes
   4. compile all sources: javac -cp $COHERENCE_HOME/lib/coherence.jar -d classes *.java
3. Start coherence cache server: java -cp classes:$COHERENCE_HOME/lib/coherence.jar com.tangosol.net.DefaultCacheServer
4. Start hello world subscriber: java -cp classes:$COHERENCE_HOME/lib/coherence.jar -Dcoherence.distributed.localstorage=false -Dcoherence.log=subscriber.log HelloWorldSubscriber
5. Start hello world publisher: java -cp classes:$COHERENCE_HOME/lib/coherence.jar -Dcoherence.distributed.localstorage=false -Dcoherence.log=publisher.log HelloWorldPublisher
6. Observe output from publisher and subscriber client.

Example of parallel consumption using a subscriber group member client.

File: HelloWorldSubscriberGroupMember.java

import com.tangosol.net.Session;
import com.tangosol.net.topic.NamedTopic;
import com.tangosol.net.topic.Subscriber;
import com.tangosol.net.topic.Subscriber.Element;
import com.tangosol.net.topic.Subscriber.Name;

public class HelloWorldSubscriberGroupMember
    {
    static public void main(String[] args)
        throws Exception
        {
        try (Session                       session       = Session.create();
             NamedTopic<String> topic           = session.getTopic("example-topic");
             Subscriber<String>     subscriber = topic.createSubscriber(Name.of("queue")))
            {
            System.out.println("HelloWorldSubscriberGroupMember for topic " + 
                               topic.getName() + " waiting to receive a value ...");
            Element<String> e = subscriber.receive().get();
            System.out.println("Received: " +  e.getValue());
            }
        }
    }
 

Add following line after existing publisher.send:

publisher.send(“goodbye world”).join();

1. Compile sources: javac -cp $COHERENCE_HOME/lib/coherence.jar -d classes *.java
2. Start coherence cache server: java -cp classes:$COHERENCE_HOME/lib/coherence.jar com.tangosol.net.DefaultCacheServer
3. Start two instances of hello world subscriber group member in different terminal windows: java -cp classes:$COHERENCE_HOME/lib/coherence.jar -Dcoherence.distributed.localstorage=false -Dcoherence.log=subscriber.log HelloWorldSubscriberGroupMember
4. Start updated hello world publisher: java -cp classes:$COHERENCE_HOME/lib/coherence.jar -Dcoherence.distributed.localstorage=false -Dcoherence.log=publisher.log HelloWorldPublisher
5. Observe output from publisher and subscriber clients. 
6. Should observe one subscriber member client received “hello world” and the other received “goodbye world”.

• Link to download Oracle Coherence
• Link to Topics Introduction screencast: Highlights functionality, Topic API and discusses the HelloWorld Messaging examples 
• Link to Subscriber Group screencast -Illustrates Subscriber Group member processing and Publisher-side partial ordering options.
• Link to Topic Configuration Tuning screencast:  Configure Topic maximum storage, Publisher-side control flow and grid-side filtering and transformations.
   

      

Part of Oracle's Enterprise Cloud Native Java portfolio, which also includes Oracle WebLogic Server 14.1.1, Coherence 14.1.1 brings significant new features to market, representing many man-years of engineering effort.

This release of Oracle Coherence is fully compatible with popular container and orchestration ecosystems certified with Coherence since 2016, for example Docker and Kubernetes.

In the themes of supporting cloud-native microservices architecture while expanding use cases enabled by the product, Coherence 14.1.1 contains the following major new functionality:

• Topics - a messaging implementation with patented scalability;
• Distributed Tracing - cross-process call trees captured using the OpenTracing API;
• GraalVM support - enabling polyglot programming on the grid side;
• JDK 11 certification throughout the release's lifecycle.

Additional enhancements contained in Coherence 14.1.1 include, for example, asynchronous persistence of cache contents to complement synchronous persistence released in Coherence version 12.2.1.

Per tradition, the Coherence product development team has prepared additional deep-dive resources on 14.1.1 new features for our users current and future.  Please refer to the rich resources on the 14.1.1 playlist on the Oracle Coherence YouTube channel.

Coherence 14.1.1 is now available to download, and the documentation for the release is published.

As always, please reach out to me for answers or assistance at any time.  Meanwhile give Coherence 14.1.1 a try, and Oracle Coherence Product Development is standing by to support your projects.

      

In these videos you'll see members of the Coherence engineering team describe and demonstrate the cool new features of Coherence 12.2.1.4 and Coherence Operator 2.0.

A listing of these videos is as follows:

* Coherence 12.2.1.4 "Management Over REST" feature
* Coherence 12.2.1.4 "View Caches" feature
* Coherence Operator 2.0 overview
* Coherence Operator 2.0 federated caching demonstration

Explore our YouTube channel for many other videos on Coherence features and knowledge, and bookmark it for future reference!  We will continue to post videos there as new developments occur in the Coherence world.

      

Coherence Operator is a Kubernetes Operator for Coherence clusters: a Coherence-specific controller extending the Kubernetes API to create, configure, and manage Coherence deployments.

The 2.0 release of Coherence Operator introduces a Kubernetes Custom Resource Definition (CRD) for Coherence clusters.  The CRD allows users to define the expected membership of a Coherence cluster, including different process roles in the cluster, and the number of replicas for each role.  This in turn enables safely scaling each role in the cluster, and validating input to Kubernetes.  Flexible port mapping and service exposure is also facilitated by the CRD, and Coherence Operator 2.0 supports clustering across Oracle Cloud Infrastructure fault domains for maximum data availability.

Coherence Operator is open-source software, hosted on GitHub, and maintained by Oracle Coherence Product Development. Docker images containing Coherence Operator releases are available on Docker Hub.

Full documentation on Coherence Operator, including a Quick Start Guide, a User Guide, a rich set of samples, and more, is hosted on GitHub Pages.

     

With this offering, customers can provision dedicated infrastructure and running Coherence clusters on OCI in a matter of minutes, selecting from a menu of resources and providing configuration parameters through a wizard interface.  Afterward, customers securely shell into the provisioned machines and manage the Coherence cluster as on any other infrastructure.

A variety of compute, network, and storage infrastructure resources are available to choose from in OCI, to accommodate the resource demands of different Coherence application workloads.  And a systemd service is available on each provisioned machine to facilitate managing Coherence cluster members.

This initial release of Coherence Cloud Edition on OCI Marketplace supports the Bring Your Own License (BYOL) model.  Customers may use purchased Oracle Coherence processor licenses for Coherence Cloud Edition on Oracle Cloud Infrastructure, with the entitlements in the edition of Coherence purchased, leveraging the 1:2 mapping from Oracle Processors to Oracle Compute Units (OCPU).

Coherence Cloud Edition on OCI Marketplace is available immediately.  Its listing page on OCI Marketplace is https://cloudmarketplace.oracle.com/marketplace/en_US/listing/64611108,  and full documentation of the offering may be found at https://docs.oracle.com/en/cloud/paas/coherence-cloud/index.html.

OCI Marketplace images are available for Coherence releases 12.2.1.3.3 and 12.2.1.4.0.  As new versions of Coherence are released, corresponding OCI Marketplace images will be created.

If you need a new Coherence environment provisioned immediately, or want to upgrade infrastructure without waiting, Coherence Cloud Edition on OCI Marketplace is the ideal solution.

     

Oracle Coherence 12.2.1.4.0 is now available for downloading at https://www.oracle.com/middleware/technologies/coherence-downloads.html, and its documentation is online at https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/index.html.

Important new features in Oracle Coherence 12.2.1.4.0 include the following:

• Docker and Kubernetes Certification: Coherence applications can be deployed in Docker images orchestrated with Kubernetes, as now covered in the Administering Oracle Coherence documentation book.
• Coherence Metrics: a metrics endpoint enabling metrics gathering systems like Prometheus to gather metrics from each cache server over HTTP in text or JSON format.
• REST Management: Coherence now supports management operations using REST, with Coherence MBeans exposed as REST resources.
• View Caches: a new recommended alternative to replicated caches, combining comparable read performance with partitioned cache consistency, safety, and persistence characteristics.
• Quorum Policies: new cluster quorum policies are available for mandating the minimum number of members that must be present before terminating a member.
• Password Providers: password providers allow you to plug in your own mechanism to provide the passwords are required as part of SSL socket provider configuration.
• Netty Support: Coherence REST can now be configured to use the Netty HTTP server.

Oracle Coherence 12.2.1.4.0 will be the long-term support patch set in the Oracle Coherence 12.2.1 line, meaning future releases in this line will be limited to patch set updates (increments of the last digit of the release number).

Oracle Coherence Product Development encourages users of Oracle Coherence 12c and earlier versions to upgrade to Oracle Coherence 12.2.1.4.0. 

     

• Oracle Coherence Product Update: The State of the Enterprise in the Cloud Era
• Oracle Coherence Customer Success Stories
• Operating Oracle Coherence Microservices with Kubernetes on Oracle Cloud Infrastructure
• Ask the Experts: Improving Business Experiences with Oracle Coherence
• And a hands-on lab, Using Oracle Coherence on Kubernetes/Oracle Cloud Infrastructure

More broadly, Oracle's Enterprise Java Application Development portfolio components Coherence, Helidon, and WebLogic Server  are featured in a large number of conference sessions; see this program guide for those listings.

At CodeOne (formerly JavaOne), themes include microservices, Kubernetes, Jakarta EE, and Helidon.

We look forward to seeing you there!

     

We are happy to announce that a new version of the Coherence Demo has just been released which can run against a Kuberenetes environment. This demo utilizes a new open source project the Coherence Operator which helps you deploy and manage Coherence within a Kubernetes environment.

The Coherence Operator is available on GitHub at https://github.com/oracle/coherence-operator while the Coherence Demo is available at https://github.com/coherence-community/coherence-demo.

While updating the Coherence Demo, we've ensured that it still runs stand-alone, or on a single machine as it did before.

The full set of pre-requisites are available in the Coherence Demonstration README, but as a quick guide I've included main requirements below:

• Kubernetes 1.11.5+, 1.12.3+, 1.13.0+
• Docker 18.03.1-ce 
• Helm 2.12.3 
• Coherence 12.2.1.3.2+ or 12.2.1.4.0+ (for Federation support)

If you wish to run the Coherence Demo on your Mac, you can with Docker Desktop version 2.0.0.3 and above.

The instructions below are summarised, with the assumption of all Coherence Demo pre-requisites met and using Docker Desktop on a MacBook Pro.

Note: You can follow the full instructions which includes pre-requisites and instructions how to enable Federation, in the README.md for the coherence-demo project.

Clone the repository using the following command:

Once you have your build environment set and Docker running, then build the Maven project using:

The above command, will create a docker image which contains the cache configuration and java classes to run the demo application.

Install the Coherence Operator Chart

Issue the following to install the Coherence Operator chart:

Install the Coherence Chart

Once installed, ensure that the pods are all running by using the following. Once the coherence-demo-0 pod has READY of 1/1, you can continue.

Port-forward the application HTTP port (8080) so that we can access the application via localhost (127.0.0.1).

Open the following URL to access the application home page - http://127.0.0.1:8080/application/index.html.

When running the stand-alone version of the Coherence Demo (See here), you could change the cluster size by adding or removing servers from the UI. When running under Kubernetes, you must the the kubectl command to scale the cluster.

For example, to scale the Coherence Demo cluster to 3 servers, you would use the following:

You can use the following, (or view the application page), to see when the cluster has been scaled.

The application should show 2 members as below.

To shutdown the Coherence Demo and Coherence Operator you use following helm command:

See the following links for more information on the Coherence Operator and Coherence Demo:

• Coherence Operator on GitHub - https://github.com/oracle/coherence-operator
• Coherence Operator Documentation - https://oracle.github.io/coherence-operator
• Coherence Demo on GithHub - https://github.com/coherence-community/coherence-demo
• Coherence Documentation - https://docs.oracle.com/middleware/1213/coherence/index.html