How to Install RethinkDB on Ubuntu 26.04, 24.04 and 22.04

RethinkDB still appeals when an application wants JSON documents, changefeeds, and a built-in browser console without adopting a heavier document database stack. To install RethinkDB on Ubuntu, use the official RethinkDB APT repository, then create an instance configuration because the package installs the service framework without starting a database node by itself.

Ubuntu 26.04, 24.04, and 22.04 can use the current upstream repository paths. This setup stores the signing key in a dedicated keyring, writes a DEB822 APT source, confirms the package candidate, starts a localhost-only instance, checks the three RethinkDB ports, and separates APT-managed updates from destructive data cleanup.

Install RethinkDB on Ubuntu

RethinkDB’s official Ubuntu installation documentation publishes an APT repository for the server package. The upstream example uses a legacy one-line source file, but Ubuntu 22.04 and newer can consume the same repository as a DEB822 .sources file with a dedicated Signed-By keyring.

Update Ubuntu and Install Repository Tools

Refresh enabled package sources, then install the small tools needed to download and convert the RethinkDB signing key. The curl command in Linux reference explains the download options if you want a deeper option breakdown.

sudo apt update
sudo apt install ca-certificates curl gpg

These commands need administrator privileges. If your account cannot use sudo yet, add a privileged account first or follow the guide to add a user to sudoers on Ubuntu.

Import the RethinkDB Signing Key

Download the RethinkDB repository key, convert the ASCII-armored key into a binary keyring, then install it under /usr/share/keyrings. The upstream URL uses a .gpg filename, but the file content is ASCII armor, so the conversion step is still required.

curl -fsSLo rethinkdb-pubkey.asc https://download.rethinkdb.com/repository/raw/pubkey.gpg
gpg --dearmor --yes -o rethinkdb-archive-keyring.gpg rethinkdb-pubkey.asc
sudo install -m 0644 rethinkdb-archive-keyring.gpg /usr/share/keyrings/rethinkdb-archive-keyring.gpg
rm -f rethinkdb-pubkey.asc rethinkdb-archive-keyring.gpg

Check the key fingerprint before trusting the new source:

gpg --quiet --show-keys --with-fingerprint /usr/share/keyrings/rethinkdb-archive-keyring.gpg

pub   rsa4096 2019-08-13 [SC] [expires: 2029-08-10]
      539A 3A8C 6692 E6E3 F69B  3FE8 1D85 E93F 801B B43F
uid                      RethinkDB <packaging@rethinkdb.com>

Add the Official RethinkDB APT Repository

Create a repository file that matches your Ubuntu codename and architecture. The guard writes the source only for the Ubuntu LTS releases and architectures verified from RethinkDB’s current repository metadata.

. /etc/os-release
arch="$(dpkg --print-architecture)"

case "$VERSION_CODENAME:$arch" in
  resolute:amd64|resolute:arm64|noble:amd64|noble:arm64|jammy:amd64|jammy:arm64)
    printf '%s\n' \
      'Types: deb' \
      "URIs: https://download.rethinkdb.com/repository/ubuntu-$VERSION_CODENAME" \
      "Suites: $VERSION_CODENAME" \
      'Components: main' \
      "Architectures: $arch" \
      'Signed-By: /usr/share/keyrings/rethinkdb-archive-keyring.gpg' \
    | sudo tee /etc/apt/sources.list.d/rethinkdb.sources > /dev/null
    ;;
  *)
    printf 'RethinkDB packages are not published for Ubuntu %s (%s) on %s.\n' "$VERSION_ID" "$VERSION_CODENAME" "$arch" >&2
    false
    ;;
esac

Confirm the source file before refreshing APT:

cat /etc/apt/sources.list.d/rethinkdb.sources

Types: deb
URIs: https://download.rethinkdb.com/repository/ubuntu-resolute
Suites: resolute
Components: main
Architectures: amd64
Signed-By: /usr/share/keyrings/rethinkdb-archive-keyring.gpg

Ubuntu 24.04 uses ubuntu-noble and Suites: noble. Ubuntu 22.04 uses ubuntu-jammy and Suites: jammy. On ARM systems, the Architectures: line uses arm64.

Refresh APT and Check the RethinkDB Candidate

Refresh APT again so Ubuntu reads the RethinkDB source, then confirm the candidate comes from the official repository.

sudo apt update
apt-cache policy rethinkdb

rethinkdb:
  Installed: (none)
  Candidate: 2.4.5~0resolute
  Version table:
     2.4.5~0resolute 500
        500 https://download.rethinkdb.com/repository/ubuntu-resolute resolute/main amd64 Packages

Ubuntu Release	Repository Suite	Default Candidate	Service Style
Ubuntu 26.04	resolute	2.4.5~0resolute	SysV init script visible through systemd
Ubuntu 24.04	noble	2.4.4~0noble	SysV init script visible through systemd
Ubuntu 22.04	jammy	2.4.4~0jammy	SysV init script visible through systemd

RethinkDB also keeps older 2.4.x packages in the Ubuntu 22.04 repository, but APT selects 2.4.4~0jammy as the current Jammy candidate by default.

Install the RethinkDB Server Package

Install the server package after the candidate check points at the correct source.

sudo apt install rethinkdb

Check the installed binary and package state:

rethinkdb --version | head -n 1
dpkg-query -W -f='${db:Status-Abbrev} ${binary:Package} ${Version}\n' rethinkdb

Example output on Ubuntu 26.04 should show the RethinkDB package branch and an installed package state:

rethinkdb 2.4.5~0resolute (x86_64-linux-gnu) (GCC 15.2.0)
ii  rethinkdb 2.4.5~0resolute

The package installs /usr/bin/rethinkdb, /etc/init.d/rethinkdb, /etc/rethinkdb/default.conf.sample, and /etc/rethinkdb/instances.d/. A database node does not begin serving data until an instance configuration exists under /etc/rethinkdb/instances.d/.

Create and Start a RethinkDB Instance on Ubuntu

RethinkDB packages on Ubuntu follow the instance-file model described in the RethinkDB startup documentation. Create one configuration file per instance, point it at a dedicated data directory, then restart the packaged service script.

Create the RethinkDB Data Directory

Create a data directory owned by the packaged rethinkdb user, then initialize it with the server binary.

sudo install -d -o rethinkdb -g rethinkdb -m 0750 /var/lib/rethinkdb/instance1
sudo -u rethinkdb rethinkdb create -d /var/lib/rethinkdb/instance1

Use a different directory name when you intentionally run more than one instance on the same Ubuntu server. Each instance needs its own data directory and port set.

Write a Localhost-Only Instance Configuration

Create a small instance file that keeps the web UI, client-driver port, and cluster port bound to the local machine. RethinkDB’s server startup documentation identifies the default ports as 8080 for the web UI, 28015 for client drivers, and 29015 for intracluster traffic.

printf '%s\n' \
'directory=/var/lib/rethinkdb/instance1' \
'bind=127.0.0.1' \
'driver-port=28015' \
'cluster-port=29015' \
'http-port=8080' \
| sudo tee /etc/rethinkdb/instances.d/instance1.conf > /dev/null

sudo chmod 0644 /etc/rethinkdb/instances.d/instance1.conf

Keep RethinkDB bound to localhost for single-server applications and local testing. Do not change bind=127.0.0.1 to a wider listener until you have an admin password, transport security, and network controls planned.

Start and Verify RethinkDB on Ubuntu

Restart the packaged service script so it reads the new instance file.

sudo /etc/init.d/rethinkdb restart

Check both the systemd compatibility state and the instance status from the RethinkDB script:

systemctl is-active rethinkdb
sudo /etc/init.d/rethinkdb status | sed -E 's/, pid [0-9]+//'

Relevant output includes the active systemd compatibility state and the running instance line:

active
rethinkdb: instance1: start/running

Confirm that RethinkDB is listening only on loopback addresses for the expected ports. IPv6-enabled hosts can also show matching [::1] rows for the same ports.

ss -lnt | grep -E ':(28015|29015|8080)\b'

Example output from an IPv6-enabled host includes both loopback families:

LISTEN 0      256        127.0.0.1:28015      0.0.0.0:*
LISTEN 0      256        127.0.0.1:8080       0.0.0.0:*
LISTEN 0      256        127.0.0.1:29015      0.0.0.0:*
LISTEN 0      256            [::1]:29015         [::]:*
LISTEN 0      256            [::1]:28015         [::]:*
LISTEN 0      256            [::1]:8080          [::]:*

Verify the web administration interface with a normal GET request. RethinkDB returns 405 Method Not Allowed to a HEAD request, so use this status-code check instead of curl -I.

curl -fsS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/

200

Use RethinkDB After Installation

RethinkDB’s first-use workflow is browser friendly. The RethinkDB administration tools documentation describes the web interface as the place to manage the cluster, review sharding and replication, and run ReQL queries through the Data Explorer.

Open the Web Administration Interface

Open http://127.0.0.1:8080 in a browser on the Ubuntu system. On a remote server, keep the RethinkDB HTTP port on localhost and reach it through an SSH tunnel, VPN, or authenticated reverse proxy instead of binding the admin UI directly to a public interface.

RethinkDB’s official quickstart uses the Data Explorer for first queries. A small local test can create a table under the default test database, insert one document, then count the table rows:

r.db('test').tableCreate('events')
r.table('events').insert([{name: 'first-check', status: 'ok'}])
r.table('events').count()

The RethinkDB quickstart expands that first session into a longer ReQL walkthrough.

Set an Admin Password Before Remote Access

RethinkDB creates an admin user with full cluster permissions and no password by default. The RethinkDB security documentation recommends setting an admin password early, and the permissions documentation notes that the web UI itself connects as admin and does not use that password for browser access.

From the local Data Explorer, set the admin password before you allow any driver or cluster access beyond the machine:

r.db('rethinkdb').table('users').get('admin').update({password: 'change_this_password'})

Replace change_this_password with a real secret. Because the web UI is not password-protected, protect port 8080 with localhost binding plus an SSH tunnel, VPN, or authenticated reverse proxy.

Review RethinkDB Network Access

A local application can use the default 127.0.0.1:28015 client-driver port without opening the database to the network. Clusters need the 29015 intracluster port between trusted nodes, and administrators need a safe path to the 8080 web interface.

Port	Purpose	Safer Default
28015	Client driver connections from applications	Keep on localhost unless a separate app host needs access
29015	Node-to-node cluster traffic	Allow only trusted cluster peers on a private network
8080	Browser-based administration UI	Keep on localhost and use an SSH tunnel, VPN, or authenticated proxy

If the Ubuntu host uses UFW, restrict any RethinkDB port to specific trusted source addresses rather than adding a broad allow rule. The guide to configure UFW on Ubuntu covers source-limited rules and status checks.

Update RethinkDB on Ubuntu

RethinkDB updates arrive through the same official APT repository. Use --only-upgrade when you want to update an already installed server package without accidentally installing RethinkDB on a system where it is absent.

sudo apt update
sudo apt install --only-upgrade rethinkdb

Example output on Ubuntu 26.04 when no newer package is available:

rethinkdb is already the newest version (2.4.5~0resolute).

Ubuntu 26.04 reports the 2.4.5~0resolute package when it is current. Ubuntu 24.04 and 22.04 currently report 2.4.4 builds from their matching suites.

Troubleshoot RethinkDB on Ubuntu

Most first-install problems come from a source file that does not match the Ubuntu codename, a missing signing key, an instance file that has not been created yet, or connecting to the wrong RethinkDB port.

APT Cannot Locate the rethinkdb Package

Start by checking whether the repository file exists and matches the local release.

cat /etc/apt/sources.list.d/rethinkdb.sources
apt-cache policy rethinkdb

If apt-cache policy rethinkdb has no candidate, recreate the source file with the release-aware command, run sudo apt update, and check the policy output again. Do not point Ubuntu 26.04 at the noble or jammy suite as a workaround.

APT Reports a RethinkDB Public Key Error

A missing or mismatched key usually appears during sudo apt update. Reimport the key into the exact path referenced by Signed-By, then refresh APT.

curl -fsSLo rethinkdb-pubkey.asc https://download.rethinkdb.com/repository/raw/pubkey.gpg
gpg --dearmor --yes -o rethinkdb-archive-keyring.gpg rethinkdb-pubkey.asc
sudo install -m 0644 rethinkdb-archive-keyring.gpg /usr/share/keyrings/rethinkdb-archive-keyring.gpg
rm -f rethinkdb-pubkey.asc rethinkdb-archive-keyring.gpg
sudo apt update

RethinkDB Is Installed But No Port Is Listening

The package can be installed correctly while no database instance is running. Check whether an instance file exists and whether the service script sees it.

ls -l /etc/rethinkdb/instances.d/
sudo /etc/init.d/rethinkdb status

If the directory is empty, create instance1.conf and restart the service. If the instance exists but fails to start, read the instance log under the configured data directory before changing ports or permissions. The tail command examples can help when you need to follow the log while restarting the service.

sudo tail -n 40 /var/lib/rethinkdb/instance1/log_file

curl -I Returns 405 Method Not Allowed

RethinkDB’s web UI can reject HEAD requests while still serving normal browser and GET requests. Use the status-code check that sends a GET request.

curl -fsS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/

A working local web UI returns 200.

rethinkdb dump Reports a Missing Python Driver

The Ubuntu server package does not provide every helper used by RethinkDB’s logical backup workflow. A bare server install can report this message when you try rethinkdb dump:

Error when launching 'rethinkdb-dump': No such file or directory
The rethinkdb-dump command depends on the RethinkDB Python driver, which must be installed.

Treat that as a missing backup-tool dependency, not as a failed server install. Review RethinkDB’s official backup documentation and validate the required client-driver setup before relying on dump or restore for production backups.

RethinkDB Logs Invalid Clustering Header

The RethinkDB startup docs explain that received invalid clustering header usually means a browser, driver, or node connected to the wrong port. Check the connection target before changing the service configuration: browsers use 8080, application drivers use 28015, and cluster peers use 29015.

Remove RethinkDB from Ubuntu

Remove the package and repository when you no longer want this RethinkDB installation. Data cleanup is separate from package removal, so back up anything important before deleting instance directories.

Stop RethinkDB and Purge the Package

Stop running instances before removing the package.

sudo /etc/init.d/rethinkdb stop
sudo apt purge rethinkdb

Remove the RethinkDB APT Source and Keyring

Delete the DEB822 source, the legacy one-line source filename used by upstream examples, and both keyring names that may exist on systems that followed older instructions. If you keep a custom RethinkDB source under another filename, leave the matching keyring in place until that source is disabled.

sudo rm -f /etc/apt/sources.list.d/rethinkdb.sources /etc/apt/sources.list.d/rethinkdb.list
sudo rm -f /usr/share/keyrings/rethinkdb-archive-keyring.gpg /usr/share/keyrings/rethinkdb-archive-keyrings.gpg
sudo apt update

Confirm the launcher is gone and no active RethinkDB source still contributes a package candidate. The hash -r command clears the current shell’s command cache before checking for the removed binary.

hash -r
command -v rethinkdb || echo "rethinkdb removed"
apt-cache policy rethinkdb

After source cleanup, the launcher check should print rethinkdb removed. The apt-cache policy command should return no package data unless another RethinkDB source remains enabled.

Delete RethinkDB Data and Logs

The next command permanently deletes RethinkDB instance data, logs, and configuration under /var/lib/rethinkdb, /var/log/rethinkdb, and /etc/rethinkdb. Back up any databases or configuration files you still need before removing these paths.

List the cleanup targets first, then remove any path you still need from the deletion command.

for path in /var/lib/rethinkdb /var/log/rethinkdb /etc/rethinkdb /run/rethinkdb; do
  [ -e "$path" ] && printf '%s\n' "$path"
done

sudo rm -rf /var/lib/rethinkdb /var/log/rethinkdb /etc/rethinkdb /run/rethinkdb

Conclusion

RethinkDB is installed on Ubuntu from the official APT repository, running as a packaged instance, and checked through the service script, listener checks, and the local web UI. Keep the admin interface private, validate the separate backup tooling before production use, and compare alternatives such as MongoDB on Ubuntu or PostgreSQL 18 on Ubuntu when a project needs a different database model.