Open Time Store™
Copyright © JUXT LTD 2018-2019


To start a Crux node, use the Java API or the Clojure crux.api.

There are two types of Crux nodes: cluster and standalone. Use a cluster node when horizontal scalability is required or when you want the guarantees that Kafka offers in terms of resiliency, availability, and retention of data.

Multiple cluster nodes participate in a cluster using Kafka as the primary store and as the central means of coordination.

The Standalone node is where a single Crux instance has everything it needs locally. This is good for experimenting with Crux and for small to medium sized deployments, where running a single instance is permissible.

Table 1. Crux Nodes
Name Transaction Log Java API

Cluster Node

Uses Kafka

Crux.startClusterNode options;


Uses local event log

Crux.startStandaloneNode options;

Crux nodes implement the ICruxAPI interface and are the starting point for making use of Crux. Nodes also implement and can therefore be lifecycle managed.

To see an example of a Crux Node being integrated into a Clojure lifecycle management framework such as Integrant, see the example Integrant node.


Crux Nodes will use the following properties:

Table 2. Nodes Configuration
Node Component Property Description




Sets the K/V Store to use, e.g. "crux.kv.rocksdb.RocksKv"




Sets the data-directory to use, e.g. "data/db-dir-1"




Kafka Servers to connect to e.g. "localhost:9092"




Port for Crux HTTP Server e.g. 8080

Standalone Node

Using a Crux standalone node is the best way to get started. Once you’ve started a standalone Crux instance as described below, you can then follow the getting started example.

Project Dependency

To add Crux as a project dependency:

  juxt/crux-core {:mvn/version "19.07-1.3.0-alpha"}

Start the standalone node:

(require '[crux.api :as crux])
(import (crux.api ICruxAPI))

(def ^crux.api.ICruxAPI node
  (crux/start-standalone-node {:kv-backend "crux.kv.memdb.MemKv"
                                 :db-dir "data/db-dir-1"
                                 :event-log-dir "data/eventlog-1"}))

For the purposes of this Hello World, we are using the simplest configuration of Crux, where all of the pluggable components are in-memory. There is no Kafka or RocksDB to worry about.

You can later stop the node if you wish:

(.close node)

Cluster Nodes

When using Crux at scale it is recommended to use multiple Crux nodes connected via a Kafka cluster.

Add Crux as a project dependency:

  juxt/crux-core {:mvn/version "19.07-1.3.0-alpha"}

And Kafka Clients:

  juxt/crux-kafka {:mvn/version "19.07-1.3.0-alpha"}

Use the API to start a cluster node, configuring it with the bootstrap-servers property in order to connect to Kafka:

(def ^crux.api.ICruxAPI node
  (crux/start-cluster-node {:kv-backend "crux.kv.memdb.MemKv"
                            :bootstrap-servers "localhost:29092"}))
If you don’t specify kv-backend then by default the cluster node will use RocksDB. You will need to add RocksDB to your list of project dependencies.

You can later stop the node if you wish:

(.close node)


Project Dependency

Add RocksDB as a project dependency:

  juxt/crux-rocksdb {:mvn/version "19.07-1.3.0-alpha"}


Set the following properties when configuring Crux nodes:

Table 3. Rocks Configuration
Property Value




i.e. "data/db-dir-1"


i.e. "data/eventlog-1"

For example when constructing the standalone node:

(def ^crux.api.ICruxAPI node
  (crux/start-standalone-node {:kv-backend "crux.kv.rocksdb.RocksKv"
                                 :db-dir "data/db-dir-1"
                                 :event-log-dir "data/eventlog-1"}))


Crux can be used programmatically as a library, but Crux also ships with an embedded HTTP server, that allows clients to use the API remotely via REST.

Set the server-port configuration property on a Crux node to expose a HTTP port that will accept REST requests.

Visit the guide on using the REST api for examples of how to interact with Crux over HTTP.


Embedded Kafka

Crux is ready to work with an embedded Kafka for when you don’t have a indendepently running Kafka available to connect to (such as during development).

Add crux-kafka-embedded to your project dependencies:

  juxt/crux-kafka-embedded {:mvn/version "19.07-1.3.0-alpha"}

See the below example code:

(require '[crux.kafka.embedded :as ek])

(def storage-dir "dev-storage")
(def embedded-kafka-options
  {:crux.kafka.embedded/zookeeper-data-dir (str storage-dir "/zookeeper")
   :crux.kafka.embedded/kafka-log-dir (str storage-dir "/kafka-log")
   :crux.kafka.embedded/kafka-port 9092})

(def embedded-kafka (ek/start-embedded-kafka embedded-kafka-options))

You can later stop the Embedded Kafka if you wish:

(.close embedded-kafka)