ArcadeDB Deployment Center

Which option should I pick?

ArcadeDB runs two ways: as a server your applications reach over the network (client-server mode), or inside your application process with no server at all (embedded Java or embedded Python). Start from what you need:

Once a server is running, the Developer Center has drivers and samples for your language.

Kubernetes with Helm

The official chart is published at https://helm.arcadedb.com/ and listed on Artifact Hub. It deploys ArcadeDB as a StatefulSet; with replicaCount above 1 it turns on Raft high availability automatically.

1. Store the root password as a secret:

kubectl create secret generic arcadedb-credentials \
  --from-literal=rootPassword='<password>'

2. Add the repository:

helm repo add arcadedb https://helm.arcadedb.com/
helm repo update

3. Install a three-server cluster:

helm install my-arcadedb arcadedb/arcadedb \
  --set replicaCount=3 \
  --set image.tag=26.10.1 \
  --set arcadedb.credentials.rootPassword.secret.name=arcadedb-credentials \
  --set arcadedb.credentials.rootPassword.secret.key=rootPassword \
  --wait

4. Reach Studio and the HTTP API from your machine:

kubectl port-forward svc/my-arcadedb-http 2480:2480

Storage is ephemeral by default. The chart's arcadedb-data, arcadedb-config, arcadedb-logs, arcadedb-tmp and arcadedb-raft volumes all start as emptyDir. For anything beyond a test, replace them with volumeClaimTemplates entries of the same name; the chart README has a worked example. The chart can also expose Prometheus metrics with a ServiceMonitor, export OTLP metrics and traces, and switch logs to JSON; all of these are off by default.

Docs: Kubernetes · source: ArcadeData/arcadedb-helm.

Maven and Gradle: embedded Java

In embedded mode the database runs inside your JVM: no server process, no network hop, and the database files sit in a directory you choose. Add the engine from Maven Central:

<dependency>
  <groupId>com.arcadedb</groupId>
  <artifactId>arcadedb-engine</artifactId>
  <version>26.10.1</version>
</dependency>

// Gradle (Kotlin DSL)
implementation("com.arcadedb:arcadedb-engine:26.10.1")

try (DatabaseFactory factory = new DatabaseFactory("./databases/mydb")) {
  Database db = factory.exists() ? factory.open() : factory.create();
  db.transaction(() -> {
    db.getSchema().getOrCreateVertexType("Person");
    db.newVertex("Person").set("name", "Alice").save();
  });
  db.close();
}

Other artifacts share the same group and version:

• arcadedb-network: the remote Java client over HTTP (RemoteDatabase).
• arcadedb-grpc-client: the remote Java client over gRPC.
• Protocol and language modules such as arcadedb-bolt and arcadedb-graphql when you embed a full server.

Docs: Java API · Embed a server in your app.

High availability clusters

ArcadeDB servers form a cluster with Raft consensus, implemented with Apache Ratis. The leader takes writes and replicates them; any node can serve reads, and replicas forward writes to the leader. Outside Kubernetes you enable it on each server with arcadedb.ha.enabled=true and an arcadedb.ha.serverList of peers (host:raftPort:httpPort, Raft on port 2434 by default). On Kubernetes, the Helm chart above does this for you. HA is part of the Apache 2.0 build.

The ArcadeData/arcadedb-deployments repository has ready-to-run scenarios, each tested in CI, with a start.sh to bring it up and a test.sh to prove it works:

Try the Docker Compose cluster

git clone https://github.com/ArcadeData/arcadedb-deployments.git
cd arcadedb-deployments/ha-cluster
./start.sh              # 3 nodes, waits until all are healthy
./test.sh               # write on node-0, read from node-1 and node-2
docker compose down -v  # tear down

Needs Docker 24+, Docker Compose 2+, curl and jq. The sample passwords in these scenarios are for local use only. Docs: High availability.