Terracotta is Network-Attached Memory

Terracotta is open source infrastructure software that makes it inexpensive and easy to scale a Java application to as many computers as needed, without the usual custom application code and databases used to share data in a cluster.

Terracotta manages mission critical data using Network-Attached Memory (NAM) technology. NAM enables Terracotta to cluster Java Virtual Machines (JVMs) directly underneath applications, and is a proven runtime approach to providing Java applications both high availability and scalability.

Terracotta's open source community of developers is sponsored by Terracotta, Inc.

Terracotta is Simple

If you know Java, you know Terracotta. The advantage to Terracotta is that a clustered application looks no different than a standard Java application.

All the concepts and frameworks you already know and use such as POJOs, Spring, Hibernate, HashMap, java.util.concurrent, synchronization and more work the same with Terracotta in a clustered context as they do in a single JVM.

You'll find that you have to do less work with Terracotta because it works naturally with your Domain Model. Traditional distributed caches and ORM technologies force your Domain Objects to be flattened or otherwise distorted to work in that particular technology. Terracotta is a true in-memory solution meaning you only work with POJOs. In fact, your objects do not even have to implement Serializable to work with Terracotta!

In other words, with Terracotta, code your application naturally, and let Terracotta do all the work to make it scalable and reliable.

What Do You Get With Terracotta?

Databases and custom development can be expensive. Terracotta gives you an alternative that's faster, easier, and just as reliable as the database. It saves you money and effort when building business critical applications.

Terracotta is durable to disk and runs at in-memory speeds, which means it's faster and more scalable than databases, distributed caches, spaces, or message-oriented replication.

Even more, you don't have to implement clustering by hand. If you use popular open source frameworks like Spring, Hibernate, and EHCache, even Grails, you can use pre-existing Terracotta Integration Modules (TIMs) to seamlessly add clustering to your application.

Some of our most popular TIMs:

• Spring - Cluster your Spring Beans fire Spring Events across the cluster
• Hibernate - Speed up Hibernate 10x or 100x
• EHCache - Fast, Coherent Replication
• Compass, Lucene - Clustered Search Indexes
• Quartz - Fire Jobs across the cluster - no JDBC or shared files required.

Beyond native framework integrations, Terracotta is a complete distributed computing platform, letting you you develop anything else your application may require.

Terracotta Features:

• Shared Heap (object replication, cross-JVM object identity)
• Distributed Locking (synchronized, wait/notify, and util.concurrent support)
• Distributed Data Structures – HashMap, ArrayList, LinkedBlockingQueue, any POJO
• Guaranteed Coherent Clustered Objects
• Automatic Persistence to Disk for Reliability
• Virtual Memory (spill your heap to Terracotta and/or to disk, transparently)
• Cluster Profiling and Visualization for easy tuning
• JMX-based monitoring and management for operational visibility and control
• Terracotta Server Array - A Highly-Available and Highly-Scalable Server Technology that powers your application

How It Works

Network-Attached Memory is similar to Network-Attached Storage (NAS). Both have a server component. Both have a client layer that works transparently underneath system I/O. And both have a network protocol to move data between the clients and server, caching data locally for fast read and write access.

A widely used version of NAS is NFS. The NFS server typically handles tens or hundreds of connected clients. The client interface is the filesystem. Just like NAS, Terracotta has clients and a server component but the interface is Java itself.

As NAS is transparent under a filesystem, NAM is transparent under the Java language. Objects in a multi-JVM application are created, manipulated, and kept consistent in NAM as files are in NAS.

Similar to high-end NAS solutions, Terracotta NAM is designed to be scaled out to a server array that provides high availability and massive scalability at the server layer.

This creates a configurable JVM-level clustering capability that provides:

• Significantly Reduced Costs for Enterprise Java Applications
• A Simple Straightforward Operations Model
• Highly Available Enterprise Java Applications
• Highly Scalabile Enterprise Java Applications
• No Single Point of Failure
• No Single Point of Bottleneck

Hello Clustered World

To provide a brief introduction, let's look at Hello Clustered World. Hello Clustered World is our take on the classic Hello World application.

In this case, it is a Java application written to run on a single JVM, to which we then add Terracotta clustering with a few small lines of configuration.