Recommended approach: migrate data from standalone (nodesCount=1) to 3-node cluster (nodesCount=3)

[abdul90082]

We are running GraphDB 10.6.3 with the Helm chart v10.6.3 in standalone mode (nodesCount = 1). We want to migrate to a new infrastructure with a 3-node cluster (nodesCount = 3) and need guidance on the best approach.

Our setup

Current (v1 — standalone):

• GraphDB 10.6.3, Helm chart 10.6.3
• clusterConfig.nodesCount = 1 (standalone)
• 346 GB data, 71 repositories
• No raft/ directory (as expected for standalone)
• Kubernetes on Hetzner dedicated servers

Target (v2 — cluster):

• Same GraphDB and Helm chart version (10.6.3)
• clusterConfig.nodesCount = 3
• Kubernetes (k3s), Longhorn storage

What we want to do

Step 1: Deploy GraphDB on v2 with nodesCount = 1 (standalone), rsync the data from v1, and verify it works. This part is straightforward — same version, same mode, just copying files between two standalone instances.

Step 2: Scale from nodesCount = 1 to nodesCount = 3 via helm upgrade. Our goal is for graphdb-node-0 (which already has the 346 GB data) to become the Raft leader, and the two new empty nodes to sync from it.

What we see in the Helm chart code

Looking at the chart templates at tag 10.6.3, the create-graphdb-cluster-job (post-start-job.yaml) runs on post-upgrade and calls createCluster:

graphdb.sh

function createCluster {                                                                                                                                                                                                                                     
  waitAllNodes $1
  local configLocation=$2                                                                                                                                                                                                                                    
  ...           
  curl -o response.json -isSL -m $timeout -X POST \                                                                                                                                                                                                          
    --header "Authorization: Basic ${authToken}" \                                                                                                                                                                                                           
    --header 'Content-Type: application/json' \                                                                                                                                                                                                              
    -d @"$configLocation" \                                                                                                                                                                                                                                  
    http://graphdb-node-0.graphdb-node:7200/rest/cluster/config                                                                                                                                                                                              
  ...                                                                                                                                                                                                                                                        
}

This POSTs the cluster config to graphdb-node-0 (our data-bearing node). The condition
{{- if gt (int .Values.graphdb.clusterConfig.nodesCount) 1 }}
means this job only runs when nodesCount > 1, which would be the case after our upgrade from 1 → 3.

Our Terraform code that controls this:

components/graphdb/main.tf

resource "helm_release" "graphdb" {                                                                                                                                                                                                                          
  chart      = "graphdb"
  version    = "10.6.3"                                                                                                                                                                                                                                      
  repository = "https://maven.ontotext.com/repository/helm-public"                                                                                                                                                                                           
 
  set {                                                                                                                                                                                                                                                      
    name  = "graphdb.clusterConfig.nodesCount"
    value = var.replicas  # 1 for standalone, 3 for cluster
  }                                                                                                                                                                                                                                                          
 
  set {                                                                                                                                                                                                                                                      
    name  = "graphdb.clusterProxy.replicas"
    value = var.replicas                                                                                                                                                                                                                                     
  }
}                                                                                                                                                                                                                                                            

Our questions

1. Is this approach valid? Deploy as standalone → rsync data → upgrade to 3-node cluster. Will GraphDB correctly form the cluster with graphdb-node-0's existing data and replicate to the empty nodes?
2. Any caveats at our scale? (346 GB / 71 repositories)
3. Is there a better approach we should consider?

Thank you!

---