REAL TERRACOTTA. Real-world scalability patterns with Terracotta. SERGIO BOSSA Pro-Netics / Sourcesense

Transcription

1 REAL TERRACOTTA Real-world scalability patterns with Terracotta SERGIO BOSSA Pro-Netics / Sourcesense

2 About Me Software architect and engineer Blogger Open Source Enthusiast Lead at Scarlet - Clustering for Jira Committer at Spring Modules Committer at Terracotta Forge

3 Agenda Do I need a cluster? Terracotta concepts. Scalability patterns with Terracotta.

4 Do I need a cluster? The old, dummy, question: Do I need a clustered architecture? The correct one: Do I need scalability? Do I need availability? Nowadays, the answer is: yes, you need.

5 Why should I need a cluster? Several changes in the social and market landscape... In a few words: More and more users surfing the web. More and more hardware at cheaper price. More and more processors... even on a single machine.

6 What should I use for my cluster?

7 The Terracotta Revolution

8 The Terracotta Revolution Transparent clustering. Everything happens under the hood. Easy to work with. If you know Java, you can cluster your application with no-to-minimal code changes. Deep integration with common frameworks and patterns. Optimized for performance. No cross-node communication. Built on the concept of diff. Open Source. With a great community.

9 Terracotta Technology Overview Network Attached Memory All cluster nodes share part of their memory heap: a shared object graph starting from one or more roots. Shared objects changes are propagated at the byte level: only the different bytes get propagated! Shared objects changes are delimited by lock-guarded transactions. Shared objects are backed by the cluster server filesystem. With preserved Java semantics (i.e. object identity)!

10 Terracotta Technology Overview Hub-and-Spoke network architecture A central cluster server with one or more cluster client nodes. Clients talk only with the server. Server can be put in active-passive mode (no SPOF). For enterprise customers only: server can be put in active-active mode (no SPOB).

11 Terracotta Technology Details Bytecode instrumentation Instrument classes in order to: Share classes among cluster nodes. Intercept and propagate changes. Apply transactions. Distribute method invocations.

12 Terracotta Technology Details Roots AKA super-static: created only for the first time, and then shared among all cluster nodes. Start of the shared object graph: all objects reachable from roots are shared among all cluster nodes. Except transient ones.

13 Terracotta Technology Details Locks Every read or write operation on a shared object state must be guarded by locks. Synchronized blocks. java.util.concurrent.locks.reentrantreadwritelock Acting as a transaction boundary. Acting as a change propagation boundary.

14 Terracotta Technology Details Distributed Method Invocation Methods called on a shared object from a cluster node, are automatically fired on the same object instance of all other cluster nodes.

15 Terracotta Technology Details Declarative configuration: XML file. Java annotations.

16 Terracotta Quick Start Plan Identify roots and related shared object graphs. Identify transactional methods. Identify classes that need to be instrumented. Identify distributed methods (optional). Choose your cluster deployment configuration: How many client nodes? How many server nodes? How much memory?...

17 Terracotta Quick Start Operate Configure the cluster. Start the Terracotta cluster server: sh tc_home/bin/start-tc-server.sh -f path/to/tc-conf.xml Start the Terracotta cluster client(s): TC_INSTALL_DIR=... TC_CONFIG_PATH=.... $TC_INSTALL_DIR/bin/dso-env.sh -q export JAVA_OPTS=${TC_JAVA_OPTS} java...

18 What about real world scalability? Feeling like lost at sea?

19 Scalability in the real world We need some patterns! Cache your data in a distributed fashion. Partition your cached data and collocate with your processing. Asynchronously write-behind to your back-end. Asynchronously de-couple components communication. Asynchronously de-couple components processing.

20 Data-affinity caching

21 Data-affinity caching In a nutshell Key concepts: Use a partition function for grouping related entries on the same distributed cache instance. Use the partition function to look up the cache instance and put/get related entries. Process the cached data on the same node it belongs to. Key features: No network traffic between cache instances. Distributed load. Higher scalability.

22 Data-affinity caching With Terracotta Use: Tim-Tree-Map-Cache Key classes: org.tc.cache.cachefactory org.tc.cache.iterracottacache

23 Asynchronous write-behind

24 Asynchronous write-behind In a nutshell Key concepts: Always write and read from your (distributed) cache. Asynchronously schedule writes to the storage. Key features: Higher throughput. Load throttling.

25 Asynchronous write-behind With Terracotta Use: Tim-Async Key classes: org.terracotta.modules.async.asynccoordinator org.terracotta.modules.async.itemprocessor

26 Asynchronous messaging

27 Asynchronous messaging In a nutshell Key concepts: Connects application components through pipes. Configure processing filters to elaborate messages and make them flow through pipes. Key features: De-coupled application components. Higher reliability. Higher scalability.

28 Asynchronous messaging With Terracotta Use: Tim-Pipes Key classes: org.terracotta.message.topology.topologymanager org.terracotta.message.topology.topology org.terracotta.message.routing.router org.terracotta.message.pipe.pipe org.terracotta.message.pipe.pipeprocessor org.terracotta.message.subscriber.subscriber org.terracotta.message.subscriber.subscriberprocessor

29 Asynchronous processing

30 Asynchronous processing In a nutshell Key concepts: Create a set of tasks. Submit tasks to a master. Tasks will be executed by workers. Eventually wait for tasks to be completed. Key features: De-coupled execution of expensive tasks. Parallel execution of tasks. Customisable routing logic. Load distribution.

31 Asynchronous processing With Terracotta Use: Tim-MasterWorker Key classes: org.terracotta.executor.distributedexecutorservice org.terracotta.executor.distributedcompletionservice org.terracotta.workmanager.statik.staticworkmanager org.terracotta.workmanager.statik.staticworker org.terracotta.workmanager.dynamic.dynamicworkmanager org.terracotta.workmanager.dynamic.dynamicworker

32 Conclusion Enjoy scalability challenges! Design your scalable architecture... Program in plain old Java... Run with Terracotta!

33 Q & A