ARTIFACTORY: Keep Artifactory on Your Chosen Database, Adopt RTFS on PostgreSQL

Products
Frog_Artifactory
Content Type
User_Guide
AuthorFullName__c
Balasubramanyam Kosuri
articleNumber
000007030
FirstPublishedDate
2026-06-29T11:41:21Z
lastModifiedDate
2026-06-29

ARTIFACTORY: Keep Artifactory on Your Chosen Database, Adopt RTFS on PostgreSQL

If Artifactory runs on a database other than PostgreSQL (for example, Oracle), you do not need to migrate the Artifactory database to adopt RTFS.
Starting with Artifactory 7.146.7, RTFS can use its own dedicated PostgreSQL while Artifactory stays on its existing database.
The change is one Helm upgrade (or a system.yaml edit) that enables RTFS and adds an rtfs.database block. The Artifactory database block is unchanged.
rtfs:

  enabled: true

  database:

    type: postgresql

    driver: org.postgresql.Driver

    url: "jdbc:postgresql://<POSTGRES_HOST>:5432/rtfs"

    user: "rtfs"                       # Helm values use "user"

    password: "<RTFS_DB_PASSWORD>"     # use Kubernetes Secrets in production


Why this matters now


Legacy federation is going away

Federation used to run inside Artifactory. That model does not scale well as federated metadata volumes grow across multiple JFrog Platform Deployments (JPDs).

JFrog extracted that logic into a standalone microservice: RTFS (Artifactory Federation Service). Legacy in-Artifactory federation is deprecated, with an ~18-month migration window and removal from new releases planned for July 2027.

If you use Federated Repositories, moving to RTFS is the long-term path.

What RTFS adds:
  • Federation monitoring dashboard
  • Federation management APIs
  • Member prioritization
  • Improved auto-healing and recovery
  • Unidirectional federation
  • Upcoming federation features

The Oracle catch — and the fix


RTFS always uses PostgreSQL for its own data (events, members, binary tasks, and related state). RTFS does not support Oracle, MySQL, or Microsoft SQL Server for its datastore, and that is not planned to change.

Before 7.146.7, RTFS could only use the same database engine as Artifactory. Teams on Oracle could not enable RTFS without changing the Artifactory database platform.

From 7.146.7 onward, keep Artifactory on Oracle (or any supported non-PostgreSQL engine) and point RTFS at a separate, dedicated PostgreSQL using rtfs.database in system.yaml or Helm values.yaml.


Architecture

On a single JPD, Artifactory and RTFS use independent database connections:
┌──────────────────────────────────────────────┐
│ JFrog Platform Deployment (JPD)              │
│                                              │
│  Artifactory  ◄──►  Artifactory database     │
│       │          (Oracle, MySQL, MSSQL,      │
│       │           or PostgreSQL)             │
│       ▼                                      │
│  RTFS         ◄──►  Dedicated PostgreSQL     │
│                     (RTFS schema only)       │
└──────────────────────────────────────────────┘

Two-site federation example:
┌─────────────────────────────────────┐    ┌─────────────────────────────┐
│ Site 1                              │    │ Site 2                      │
│                                     │    │                             │
│  Oracle ◄────── Artifactory         │    │  Artifactory ──► (its DB)   │
│                    │                │    │                             │
│  PostgreSQL ◄── RTFS                │    │  (peer site)                │
│                                     │    │                             │
└─────────────────────────────────────┘    └─────────────────────────────┘
                    │                                   ▲
                    └──────── federated-repo sync ──────┘

Peer JPDs do not need the same Artifactory database engine. They only need reachable Artifactory endpoints and established trust.



Prerequisites

Requirement

Why

Artifactory ≥ 7.146.7

Introduces dedicated RTFS database configuration (rtfs.database).

Artifactory Helm chart ≥ 107.146.7

Matching chart that exposes rtfs.database values.

Empty PostgreSQL ≥ 13 dedicated to RTFS

RTFS runs Flyway on first start and creates its own schema.



Step 1 — Starting point: Artifactory on Oracle

This is a standard Oracle-backed Artifactory Helm install. Relevant values:
postgresql:
  enabled: false          # do not use the chart's bundled Postgres for Artifactory

database:
  allowNonPostgresql: true
  type: oracle
  driver: oracle.jdbc.OracleDriver
  url: "jdbc:oracle:thin:@<ORACLE_HOST>:1521/FREEPDB1"
  user: "artifactory"
  password: "<ARTIFACTORY_DB_PASSWORD>"

 

The Oracle JDBC driver is not bundled with Artifactory. Ship ojdbc11.jar in a custom image or mount it into Tomcat's lib directory. Do not download it on every pod start in production.

Demo-only preStartCommand example:
artifactory:
  preStartCommand: >-
    mkdir -p /opt/jfrog/artifactory/var/bootstrap/artifactory/tomcat/lib &&
    curl -fsSL -o /opt/jfrog/artifactory/var/bootstrap/artifactory/tomcat/lib/ojdbc11.jar
    https://repo1.maven.org/maven2/com/oracle/database/jdbc/ojdbc11/23.5.0.24.07/ojdbc11-23.5.0.24.07.jar


Step 2 — Provision dedicated PostgreSQL for RTFS

Create an empty database and owner. RTFS owns the schema; you only provision connectivity.
CREATE USER rtfs WITH PASSWORD '<RTFS_DB_PASSWORD>';
CREATE DATABASE rtfs OWNER rtfs;
GRANT ALL PRIVILEGES ON DATABASE rtfs TO rtfs;
Production: use managed or HA PostgreSQL with backups. RTFS is part of the federation control plane.


Step 3 — Enable RTFS (Helm)

Compare before and after. The Artifactory database (Oracle) block is identical. Only the rtfs block changes:
 rtfs:
-  enabled: false
+  enabled: true
+  database:
+    type: postgresql
+    driver: org.postgresql.Driver
+    url: "jdbc:postgresql://<POSTGRES_HOST>:5432/rtfs"
+    user: "rtfs"
+    password: "<RTFS_DB_PASSWORD>"

 

Run helm upgrade with your values file.


Secrets (production)


Do not store passwords in plain text in chart values:
rtfs:
  enabled: true
  database:
    secrets:
      url:
        name: my-rtfs-db-secret
        key: db-url
      user:
        name: my-rtfs-db-secret
        key: db-user
      password:
        name: my-rtfs-db-secret
        key: db-password


Step 3 (alternate) — Enable RTFS (system.yaml)

For RPM/Debian, archive/tarball, Docker Compose, or VM deployments, edit:
$JFROG_HOME/artifactory/var/etc/system.yaml
shared:
  database:
    allowNonPostgresql: true
    type: oracle
    driver: oracle.jdbc.OracleDriver
    url: "jdbc:oracle:thin:@<ORACLE_HOST>:1521/FREEPDB1"
    username: "artifactory"
    password: "<ARTIFACTORY_DB_PASSWORD>"

rtfs:
  enabled: true
  database:
    type: postgresql
    driver: org.postgresql.Driver
    url: "jdbc:postgresql://<POSTGRES_HOST>:5432/rtfs"
    username: "<RTFS_DB_USER>"        # system.yaml uses "username" (Helm uses "user")
    password: "<RTFS_DB_PASSWORD>"

 

Your existing shared.database block does not change. You only add the rtfs block. Restart Artifactory so the platform starts RTFS.


Step 4 — Verify RTFS is running

Liveness endpoint (Artifactory 7.117.5+ / 7.111.12+):
curl -s -o /dev/null -w "%{http_code}\n" \
  https://<JFROG_PLATFORM_URL>/rtfs/api/v1/system/liveness
# → 200

 

On Kubernetes, RTFS pod logs should show JDBC connectivity and Flyway migrations on first start:
kubectl -n <NAMESPACE> logs <RTFS_POD> | grep -iE "postgres|jdbc:postgres|flyway"


Step 5 — Federate end to end

With RTFS healthy, configure federated repositories and JPD trust as usual. Existing trust and federation configurations continue to work when you enable RTFS on an already federated environment.

Step

API

Where

1. Set custom Base URL

PUT /artifactory/api/system/configuration/baseUrl

Both sites

2. Generate pairing token

POST /artifactory/api/v1/service_trust/pairing/federated-repo/*

Source

3. Exchange token

PUT /artifactory/api/v1/service_trust/pairing/federated-repo/*

Target

4. Create federated repo

PUT /artifactory/api/repositories/<key> with rclass: federated

Source

In production, prefer establishing trust through the JFrog UI or vetted automation rather than ad-hoc API calls.


Step 6 — Migrate existing federated repositories

If you already run Federated Repositories on legacy (in-Artifactory) federation, enabling RTFS is not the full job. You must also migrate existing federation configurations, states, and events to RTFS.

Prerequisite: RTFS is enabled and healthy (Step 4).

Important: No Full Sync operations may be running during migration.
jf rt curl api/federation/state | jq '.[] | select(.status == "FULL_SYNC_RUNNING")'
Run the migrator:
jf plugin install federation-migrator
jf federation-migrator migrate_rtfs <BASE_URL> <ACCESS_TOKEN>

 

Where:
  • <BASE_URL> — JFrog Platform URL (without /artifactory)
  • <ACCESS_TOKEN> — admin access token

Production hardening checklist
  •  Use rtfs.database.secrets (and existingSecret for Artifactory credentials), not inline passwords
  •  Run managed / HA PostgreSQL for RTFS with backups
  •  Set resource requests/limits, HPA, and PodDisruptionBudgets per chart docs
  •  Establish JPD trust through the UI or supported automation
  •  Verify no Full Sync is running before migration
  •  Run jf federation-migrator migrate_rtfs after RTFS is healthy

FAQ (internal)


Does RTFS ever use Oracle? No. RTFS always uses PostgreSQL for its own datastore.

Does Artifactory need to move to PostgreSQL? No, from 7.146.7 onward, if you configure rtfs.database with a dedicated PostgreSQL.

Does the peer JPD need Oracle + PostgreSQL too? Only if that JPD also runs RTFS. The peer's Artifactory database engine is irrelevant to federation sync; it needs a reachable Artifactory endpoint and trust.

Helm user vs system.yaml username? Helm chart values use user under rtfs.database. In system.yaml, use username.


References