ArcadeDB 26.7 Multi-Model Database on Ubuntu 24.04 on Azure User Guide

Overview

This guide covers the deployment and configuration of ArcadeDB 26.7 Multi-Model Database on Ubuntu 24.04 on Azure using cloudimg Azure Marketplace images. ArcadeDB is a multi-model database that stores graph, document, key value, time series and vector data in a single engine, and queries it with SQL, Cypher, Gremlin, GraphQL, plus MongoDB and Redis protocol compatibility. It ships a built in Studio web workbench for modelling schema, running queries and browsing graphs. ArcadeDB is a conceptual fork of OrientDB and is released under the Apache License 2.0.

The image installs the official ArcadeDB server distribution (version 26.7.2 at build time) to /opt/arcadedb, running under OpenJDK 21. The ArcadeDB HTTP listener (Studio plus the REST API) is bound to loopback only and fronted by nginx on port 80, so the only public surface is a single standard HTTP port. The database storage directory lives on a dedicated Azure data disk mounted at /var/lib/arcadedb, independent of the OS disk. At first boot, arcadedb-firstboot.service generates a unique per VM root password (there is no default login baked into the image), starts the server, seeds a small Demo graph, proves an authenticated round trip against the HTTP API, and writes the password to /root/arcadedb-credentials.txt (mode 0600, root only).

What is included:

• ArcadeDB 26.7 server (full distribution, all query engines and Studio) from the official GitHub release, pinned and sha256 verified

• OpenJDK 21 JRE headless (ArcadeDB requires Java 17 or newer)

• arcadedb.service systemd unit running the server as the unprivileged arcadedb user

• arcadedb-firstboot.service systemd oneshot that generates the per VM root password, starts the server, seeds the Demo graph and writes /root/arcadedb-credentials.txt

• nginx on port 80 reverse proxying to the loopback bound ArcadeDB HTTP listener, with an unauthenticated /healthz for load balancer probes

• ArcadeDB Studio web UI, the multi-model query workbench, reachable at http://<vm-ip>/

• Database storage on a dedicated 30 GiB data disk mounted at /var/lib/arcadedb, captured into the image so every VM is provisioned with it

• Ubuntu 24.04 LTS base with the latest security patches

• Azure Linux Agent for seamless cloud integration and SSH key injection

• 24/7 cloudimg support with guaranteed 24 hour response SLA

Prerequisites

• An active Azure subscription, SSH public key, VNet plus subnet in the target region

• A subscription to the ArcadeDB 26.7 on Ubuntu 24.04 listing on Azure Marketplace

Recommended virtual machine size: Standard_B2s (2 vCPU, 4 GB RAM) for evaluation and light workloads. For production graph and document workloads use Standard_E4s_v5 (4 vCPU, 32 GB RAM) or larger, and raise the JVM heap in /etc/default/arcadedb (ARCADEDB_OPTS_MEMORY=-Xms1G -Xmx8G).

Step 1: Deploy from the Azure Portal

Search ArcadeDB in Marketplace, select the cloudimg publisher entry, then click Create.

NSG rules: allow TCP 22 from your management IP and TCP 80 from your client IPs. The ArcadeDB HTTP listener is bound to loopback, so only nginx on port 80 is exposed. Do not expose port 80 to the public internet without a TLS terminating reverse proxy in front.

Step 2: Deploy from the Azure CLI

RG="arcadedb-prod"; LOCATION="eastus"; VM_NAME="arcadedb-01"
GALLERY_IMAGE_ID="/subscriptions/<sub-id>/resourceGroups/azure-cloudimg/providers/Microsoft.Compute/galleries/cloudimgGallery/images/arcadedb-ubuntu-24-04/versions/<version>"
SSH_KEY="$(cat ~/.ssh/id_rsa.pub)"
az group create --name "$RG" --location "$LOCATION"
az network vnet create -g "$RG" --name arc-vnet --address-prefix 10.80.0.0/16 --subnet-name arc-subnet --subnet-prefix 10.80.1.0/24
az network nsg create -g "$RG" --name arc-nsg
az network nsg rule create -g "$RG" --nsg-name arc-nsg --name allow-ssh --priority 100 \
  --source-address-prefixes "<your-mgmt-cidr>" --destination-port-ranges 22 --access Allow --protocol Tcp
az network nsg rule create -g "$RG" --nsg-name arc-nsg --name allow-http --priority 110 \
  --source-address-prefixes "<your-client-cidr>" --destination-port-ranges 80 --access Allow --protocol Tcp
az vm create -g "$RG" --name "$VM_NAME" --image "$GALLERY_IMAGE_ID" \
  --size Standard_B2s --storage-sku StandardSSD_LRS \
  --admin-username azureuser --ssh-key-values "$SSH_KEY" \
  --vnet-name arc-vnet --subnet arc-subnet --nsg arc-nsg --public-ip-sku Standard

Step 3: Connect via SSH

ssh azureuser@<vm-ip>

Both arcadedb.service and nginx.service are started automatically once arcadedb-firstboot.service has generated the per VM root password on the first boot.

Step 4: Verify the ArcadeDB Service

sudo systemctl is-active arcadedb.service nginx.service
sudo test -f /var/lib/cloudimg/arcadedb-firstboot.done && echo FIRSTBOOT_DONE
sudo systemctl status arcadedb.service --no-pager | head -8

Both services should report active, and the first boot sentinel should be present.

Step 5: Inspect the Listeners and Version

The ArcadeDB HTTP listener is bound to 127.0.0.1:2480 and nginx serves it on port 80. There is no open JMX or management port.

sudo journalctl -u arcadedb.service --no-pager | grep -E 'ArcadeDB Server started|Available query languages' | tail -2
sudo ss -tln | grep -E ':2480|:80 '

Step 6: Retrieve the Root Password

The per VM root password is generated at first boot and stored in a root only file:

sudo cat /root/arcadedb-credentials.txt

You will see the root user, the per VM password, and the endpoint URLs:

ARCADEDB_ROOT_USER=root
ARCADEDB_ROOT_PASSWORD=<ARCADEDB_PASSWORD>
ARCADEDB_STUDIO_URL=http://<vm-ip>/
ARCADEDB_HTTP_API_URL=http://<vm-ip>/api/v1/
ARCADEDB_DEMO_DATABASE=Demo

Step 7: Query the HTTP REST API

ArcadeDB exposes a full REST API. Extract the password into a shell variable and run an authenticated query against the seeded Demo database:

PW=$(sudo grep '^ARCADEDB_ROOT_PASSWORD=' /root/arcadedb-credentials.txt | cut -d= -f2-)
curl -s -u "root:$PW" http://127.0.0.1/api/v1/databases
curl -s -u "root:$PW" -H 'Content-Type: application/json' -X POST http://127.0.0.1/api/v1/command/Demo \
  -d '{"language":"sql","command":"SELECT name, role FROM Person ORDER BY name"}'

The first call lists the databases (Demo); the second returns the three Person records from the sample graph.

Step 8: Open ArcadeDB Studio

ArcadeDB Studio is the built in web workbench. Open http://<vm-ip>/ from your workstation (assuming the NSG allows TCP 80). The sign in page shows the multi-model overview and asks for a username and password:

Sign in with user root and the per VM password from /root/arcadedb-credentials.txt. Studio connects to the Demo database and shows the Database Info panel with the seeded schema, Person vertices and Knows edges:

Step 9: Run a Query in Studio

Type a query into the editor, choose a language (SQL, Cypher, Gremlin, GraphQL and more are available), and press Run. The Table view shows the returned records:

Step 10: Browse the Graph

Switch the result view to Graph to explore vertices and their relationships visually. The Demo graph shows the Person vertices connected by directed Knows edges:

Step 11: Multi-Model Query Examples

ArcadeDB runs several query languages against the same data. Create your own database and try a few. Extract the password first:

PW=$(sudo grep '^ARCADEDB_ROOT_PASSWORD=' /root/arcadedb-credentials.txt | cut -d= -f2-)
curl -s -u "root:$PW" -H 'Content-Type: application/json' -X POST http://127.0.0.1/api/v1/command/Demo \
  -d '{"language":"cypher","command":"MATCH (p:Person)-[:Knows]->(f:Person) RETURN p.name, f.name"}'

The same graph can be traversed with Cypher (as above), with SQL (SELECT expand(out('Knows')) FROM Person), or with Gremlin (g.V().hasLabel('Person').out('Knows').values('name')). ArcadeDB also speaks the MongoDB and Redis wire protocols for document and key value access.

Step 12: Server Components

Step 13: Managing the ArcadeDB Service

sudo systemctl status arcadedb.service --no-pager | head -6
sudo journalctl -u arcadedb.service --no-pager | tail -5

To restart the service after a configuration change, run sudo systemctl restart arcadedb.service.

Step 14: Security Recommendations

• Rotate the root password in Studio (Security tab) or via the API, and store it in your secrets manager

• Keep the HTTP listener on loopback as shipped; expose only nginx on port 80, and put TLS in front of it (Azure Application Gateway, or nginx with a real certificate)

• Restrict the NSG so port 80 only reaches trusted client networks, never the public internet without TLS

• Create per application users and roles in the Security tab instead of using the root account for application traffic

• Back up the databases directory at /var/lib/arcadedb/databases, or use ArcadeDB's built in backup command

• Patch the OS monthly with sudo apt-get update && sudo apt-get upgrade && sudo reboot

Step 15: Support and Licensing

ArcadeDB is licensed under the Apache License 2.0. There are no per node, per CPU, or per GB fees. This image is produced by cloudimg and is not affiliated with, endorsed by, or sponsored by Arcade Data Ltd; ArcadeDB is a trademark of its respective owner and is used here only to describe the software included in the image.

cloudimg provides commercial support for this image separately from the upstream project.

• Email: support@cloudimg.co.uk

• Website: www.cloudimg.co.uk

• Support hours: 24/7 with guaranteed 24 hour response SLA

Deploy on Azure

Launch ArcadeDB 26.7 Multi-Model Database on Ubuntu 24.04 with 24/7 support from cloudimg.

View on Marketplace

Need Help?

Our support team is available 24/7.

support@cloudimg.co.uk