Best experienced on desktop

This page uses diagrams and tables designed for larger screens. Open it on your laptop for the full experience.

Orbit for Self-Managed

A full Orbit deployment running inside your network. Your SDLC data never leaves your environment. GKG, Siphon, NATS, and ClickHouse — all on Kubernetes, connected to your existing GitLab instance.

Self-managed Orbit is experimental and not covered by GitLab SLA. We are running a hands-on design partner program before general availability. Engineering onboards all early adopters directly.
2
Deployment Paths
OAK (Omnibus + K8s) or Helm chart extension
4
Core Components
GKG, Siphon, NATS, ClickHouse
~10
Min K8s Nodes
3 ClickHouse + 3 NATS + 2+ GKG indexers + 2+ GKG web
Zero
Data Egress
Cluster can be fully network-separated from GitLab.com
Architecture

Two paths to production.

Choose based on how you run GitLab today. Both paths deliver the same GKG capabilities.

OAK — Omnibus + Kubernetes

Your GitLab instance runs on a Linux server via the Omnibus package (the standard self-managed install). GKG runs on a separate Kubernetes cluster that you provision alongside it. The two communicate over TLS and don't need to share a network.

Choose this if you installed GitLab with gitlab-ee or gitlab-ce on a VM or bare metal.
Helm — Cloud-Native GitLab

Your GitLab instance already runs on Kubernetes using the official gitlab/gitlab Helm chart. You extend your existing cluster by deploying the GKG Helm charts alongside it - no new cluster needed, GKG connects to GitLab via internal Kubernetes services.

Choose this if you deployed GitLab with helm install gitlab gitlab/gitlab.
GitLab Instance (Omnibus)
GitLab Rails
Existing install, unchanged
PostgreSQL
Source for Siphon replication
Gitaly
Repository data for code indexing
TLS / network-sep OK
Separate Kubernetes Cluster
Siphon
Streams Postgres WAL into graph
NATS
Messaging bus, 3-node HA
GKG Indexer
Code + metadata indexing pods
GKG Web
Query API, 2+ pods for HA
ClickHouse
Customer-provisioned, 3-node HA
The Kubernetes cluster does not need to share a network with your Omnibus instance. TLS is fully supported for separated deployments - your source code never traverses the public internet.
Existing Kubernetes Cluster (GitLab)
gitlab/gitlab Helm chart
Your existing cloud-native install
PostgreSQL (bundled)
Siphon connects via internal service
Gitaly
Existing pod, no changes needed
Same cluster
GKG Helm Charts (extend same cluster)
gitlab/gkg chart
Deploys Siphon + GKG pods
NATS StatefulSet
Deployed via GKG chart, 3-node
GKG Indexer + Web
Same pods as OAK path
ClickHouse
Separate, customer-provisioned
Helm deployments extend your existing gitlab/gitlab chart. No changes to your GitLab pods - GKG components run alongside in the same cluster and connect via internal Kubernetes services.
Components

What you're deploying.

Four components. Three of them are new. One (ClickHouse) you provision separately.

Core service

GKG — GitLab Knowledge Graph

The indexing and query engine. Processes raw SDLC events from Siphon, builds the graph, and serves the query_graph and get_graph_schema API endpoints. Runs as two separate workloads: Indexer (write-heavy) and Web (query-serving).

Indexer nodesMin 2, ~3 GB RAM each
Web nodesMin 2 for HA, ~1 GB RAM each
Scale signal3 GB+ per pod for large repos
HA requiredYes - min 2 replicas each
Data pipeline

Siphon

Captures PostgreSQL WAL (write-ahead log) from your GitLab database and streams SDLC events into NATS. Siphon is the bridge between your existing GitLab data and the knowledge graph. It reads from PostgreSQL logical replication slots - no schema changes to your GitLab DB.

Data sourcePostgreSQL WAL (logical replication)
DownstreamNATS message bus
GitLab DB changesNone required
Operational maturityPosture still being defined
Messaging

NATS

High-performance messaging bus that buffers events between Siphon and the GKG indexer. Runs as a 3-node StatefulSet for fault tolerance. Deployed and managed by the GKG Helm chart - you don't configure NATS directly beyond sizing.

Nodes3 (HA StatefulSet)
CPU per node~4 vCPU
RAM per node~8 GB
Managed byGKG Helm chart
Storage (bring your own)

ClickHouse

The analytics database that stores the knowledge graph. You provision this separately - either ClickHouse Cloud or self-managed ClickHouse on your own infrastructure. GKG reads and writes to it; you own the sizing, backups, and upgrades. Baseline storage: roughly one-third of your total PostgreSQL database size.

Provisioned byYou (not bundled)
Nodes3 (~4 vCPU / 16 GB each)
Storage baseline~1/3 of PostgreSQL DB size
OptionsClickHouse Cloud or self-hosted
Deployment

How the install works.

GitLab engineering works with you hands-on for all design partner deployments. This is what the process looks like end to end.

1

Provision your Kubernetes cluster

Stand up a dedicated K8s cluster (GKE, EKS, AKS, or on-prem) for GKG. It does not need to share a VPC with your GitLab Omnibus server - just reachability over TLS.

Minimum recommended: 10 nodes across ClickHouse (3), NATS (3), GKG Indexer (2+), GKG Web (2+). Exact sizing depends on your repo count and query load.
2

Deploy ClickHouse

Provision a 3-node ClickHouse cluster (ClickHouse Cloud or self-hosted) and note the connection string. Storage baseline is roughly one-third your PostgreSQL database size.

ClickHouse is not bundled. You own provisioning, credentials, backups, and upgrades. GitLab will provide the required schema and connection config.
3

Enable PostgreSQL logical replication on your GitLab instance

Siphon reads from PostgreSQL WAL. You need to enable logical replication and create a replication slot. No schema changes to your GitLab DB required.

# In postgresql.conf
wal_level = logical
max_replication_slots = 5
max_wal_senders = 5

# Then create the replication slot
SELECT pg_create_logical_replication_slot('gkg_siphon', 'pgoutput');
4

Deploy GKG components via Helm

Add the GitLab Helm repository and install the GKG chart with your configuration. GitLab will provide the chart values file as part of the onboarding.

helm repo add gitlab https://charts.gitlab.io/
helm repo update

helm install gkg gitlab/gkg \
  --namespace gkg \
  --create-namespace \
  -f gkg-values.yaml
GitLab engineering provides your gkg-values.yaml during onboarding. It includes your ClickHouse credentials, PostgreSQL replication config, and GKG endpoint settings.
5

Connect Orbit in GitLab admin settings

In your GitLab instance admin panel, configure the GKG endpoint URL and authentication token. This links your GitLab instance to the GKG web service running on your K8s cluster.

Admin settings path: Admin → Settings → GitLab Duo → Orbit / Knowledge Graph
6

Enable indexing for your groups

As a GitLab admin or top-level group Owner, enable Orbit indexing per group. Indexing starts on the main branch. Full initial index time depends on repo count and size.

Indexing is all-or-nothing per group. You cannot exclude individual projects within a group. Plan your group selection carefully for the initial rollout.
1

Confirm you're on the GitLab cloud-native Helm chart

This path is for customers already running gitlab/gitlab on Kubernetes. If you're on Omnibus, use the OAK path instead.

helm list --all-namespaces | grep gitlab
2

Deploy ClickHouse

Same as OAK: provision a 3-node ClickHouse cluster separately. ClickHouse Cloud or self-hosted both work. Storage baseline is roughly one-third your PostgreSQL DB size.

ClickHouse is not bundled in the GKG chart and must be provisioned before you install GKG.
3

Add GKG chart to your existing GitLab namespace

Install the GKG chart into the same namespace as your GitLab deployment. GKG will discover your PostgreSQL and Gitaly services automatically via Kubernetes DNS.

helm install gkg gitlab/gkg \
  --namespace gitlab \
  -f gkg-values.yaml
Running in the same namespace as your gitlab release lets Siphon connect to PostgreSQL and Gitaly via internal Kubernetes service discovery - no external networking required.
4

Connect and enable in GitLab admin

Same final steps as OAK: configure the GKG endpoint in admin settings, then enable indexing per group from admin or group Owner settings.

Because GKG runs in the same cluster, the endpoint URL will be an internal Kubernetes service DNS name, not a public URL.
Infrastructure

Sizing requirements.

These are baseline specs. Production sizing will vary based on group count, repo sizes, and query volume.

Component Nodes CPU / node RAM / node Storage Notes
ClickHouse 3 ~4 vCPU ~16 GB ~1/3 of PostgreSQL DB size Customer-provisioned. Not bundled. Cloud or self-hosted.
NATS 3 ~4 vCPU ~8 GB Minimal (messaging buffer) Deployed by GKG chart as StatefulSet. 3-node HA.
GKG Indexer 2+ (HA) ~4 vCPU ~3 GB+ Ephemeral (stateless) 3+ GB per pod for large or complex repositories.
GKG Web 2+ (HA) ~2 vCPU ~1 GB Ephemeral (stateless) Query-serving pods. Minimum 2 for HA.
Siphon 1+ ~2 vCPU ~2 GB Ephemeral (stateless) Single instance acceptable; HA config available.
Persistent Volumes - - NATS: ~20 GB per node PVCs for NATS StatefulSet. StorageClass must support ReadWriteOnce.
Prerequisites

What you need before you start.

Go through this list before your onboarding call with the GitLab team.

Infrastructure

Kubernetes cluster (GKE, EKS, AKS, or on-prem)
ClickHouse deployment provisioned and accessible
Helm 3.x installed with access to the cluster
Persistent volume provisioner (StorageClass configured)
Network path from K8s cluster to GitLab PostgreSQL and Gitaly

GitLab Licensing & Access

Premium or Ultimate license
Duo Enterprise or Duo Developer add-on
GitLab instance admin access
Top-level group Owner permissions for groups you want to index
GitLab minimum version (provided at onboarding; TBD for GA)

Database

PostgreSQL logical replication enabled (wal_level = logical)
Available replication slots (max_replication_slots ≥ 5)
PostgreSQL credentials for Siphon replication user
ClickHouse credentials (host, port, username, password)

Networking & Access

Allowlist access to GitLab Container Registry (dependency proxy)
Internal DNS or IP reachability between K8s cluster and GitLab
TLS certificate or internal CA for encrypted transport (recommended)
GitLab group Owner or admin able to join onboarding session
Indexing Model

What gets indexed and how.

Indexing is controlled by admins at the group level. Here's what to plan for.

Indexing rules

Enabled per group via admin UI or group settings. Admins and group Owners can control it.
Main branch only. Feature branches and merge request branches are not indexed.
All-or-nothing per group. You cannot exclude individual projects within an indexed group.
Initial indexing runs on deploy. Incremental updates stream in near-real-time via Siphon + NATS.
Indexing time scales with repo count and size. GitLab will benchmark your environment during onboarding.
Admin › GitLab Duo › Orbit Indexing
Admin › Settings › GitLab Duo › Orbit
Group Indexing
⬡
acme-corp / platform-engineering
Indexed
⬡
acme-corp / data-science
Indexing…
⬡
acme-corp / mobile-apps
Not enabled
⬡
acme-corp / legacy-systems
Not enabled
Admin UI mock. Actual UI is in development - design subject to change.

Language support

Ruby Java Kotlin Python TypeScript JavaScript C# Rust Go C C++ Swift COBOL
Full indexing (symbols + cross-file references)
Definitions + intra-file references (cross-file in progress)
Definitions + imports only
Not yet indexed
Timeline

Where we are.

Q2 FY27
Target for self-managed GA
Design partner onboarding starts now for .com
Self-managed DPs being selected for pre-GA access
GA includes monetization and SLA coverage
Now
Experimental design partner program
GitLab engineering onboards hands-on
Not covered by GitLab SLA
Direct feedback loop to the product team

Ready to bring Orbit to your instance?

We're onboarding a small set of self-managed design partners now. You'll work directly with the GKG engineering team and shape the deployment experience before GA.

Join the Self-Managed Waitlist

You'll hear back from the GKG team within a few business days.