Self-Hosted Standalone Installation Guide

This guide covers the installation of Develocity into a single host.

Develocity is a Kubernetes-based application, distributed as a Helm chart. Helm is a package manager for Kubernetes applications. In a standalone installation, you install the K3s lightweight Kubernetes distribution onto the host. You then use Helm to install Develocity into that K3s instance. Helm manages all Develocity components.

For instructions on installing Develocity on a host without public network connectivity, see Airgap Installation.

Prerequisites

Develocity License

If you have purchased Develocity or started a trial, you should already have a license file called develocity.license. Otherwise, you can request a Develocity trial license.

Host Requirements

Operating System

Develocity is expected to work on most modern Linux systems (x86_64 only). The operating system requirements are mainly the same as those for the used K3s Kubernetes distribution.

K3s

K3s needs several ports to be accessible from the host.

Protocol Port

TCP

6443

TCP

10250

UDP

8472

While these ports don’t need to be accessible from outside the host machine, K3s may access them using a different network interface or non-localhost IP.

RHEL / CentOS Stream

On Red Hat Enterprise Linux and CentOS Stream hosts, if nm-cloud-setup is enabled, you must disable the service and reboot the system.

🔍 Disable nm-cloud-setup.service

First, check if the nm-cloud-setup.service is enabled on your system:

sudo systemctl is-enabled nm-cloud-setup.service

If the service is disabled, the command returns disabled, otherwise it returns enabled.
If nm-cloud-setup is enabled, disable it with the following command:

sudo systemctl disable nm-cloud-setup.service nm-cloud-setup.timer

Reboot the system:

sudo systemctl reboot

Disabling firewalld is recommended, too. If you can’t, ensure that the ports mentioned above are accessible and enable IP address masquerading. This can be done with the following command:

firewall-cmd --add-masquerade --permanent

For more details on IP address masquerading, see the Red Hat documentation.
For more details on the RHEL / CentOS requirements, see the K3s documentation.

CPU & Memory

The minimum installation requirements are:

  • 10 CPUs (x86_64 architecture)

  • 24 GiB of memory

Database

By default, Develocity stores its data in a PostgreSQL database that runs as part of the application itself. The data lives in a directory mounted on the host machine.

Develocity installations have two database options:

  1. An embedded database, which depends heavily on disk performance.

  2. A user-managed database, which can be any PostgreSQL database compatible with versions 15 through 18.

The compatibility matrix lists the supported versions for every Develocity release.

 Using PgBouncer with a user-managed database is not supported.

Storage

In addition to the database, Develocity needs storage capacity for configuration files, logs, Build Cache artifacts, and database backups. To simplify managing disk space, Gradle recommends mounting separate persistent storage volumes for data, logs, and backups.

Capacity

By default, Develocity stores its data under /opt/gradle. You can remount each subdirectory to a separate persistent volume with the global.storage.* Helm values. Develocity recommends a dedicated volume for the installation directory, with at least 10% of the volume’s space free at all times.

Location Helm Value Minimum Size Notes

/opt/gradle

global.storage.directory

Sum of the layers below

This volume hosts multiple storage layers stacked on the same SSD. Size it as the sum of the layers that apply to your configuration:

Layer Default size Present when

Application data and logs

~5 GiB

Always

Co-located Edge node cache

50 GiB (edgeNode.storage.data.capacity)

Always

Embedded object storage (durable Build Cache + monitoring + internal buffer)

75 GiB (sum of objectStorage.embedded.storage.{internalBuffer,buildCache,monitoring}.capacity)

objectStorage.type: embedded (the standalone default; external object storage moves these off this volume)

Embedded database with Build Scan retention

~250 GiB recommended (grows with Build Scan volume × retention)

Embedded database mode (the standalone default)

Requires SSD performance.

/opt/gradle/logs

global.storage.logs.directory

10 GiB

Application logs.

/opt/gradle/backups

global.storage.backup.directory

250 GiB

Database backups. Applicable only when using the embedded database.

/var/lib/rancher/k3s

-

30 GB

K3s runtime. Not performance-sensitive.

The four layers above are independent, so adding capacity to one does not help the others.

  • The durable Build Cache lives inside the embedded object storage row, where the Build Cache target storage size setting governs its size, up to the objectStorage.embedded.storage.buildCache.capacity limit. See Space Management for sizing.

  • The co-located Edge node cache is a separate, ephemeral low-latency cache on this same volume that serves recent artifacts to build agents. Size edgeNode.storage.data.capacity to hold your active working set: the artifacts for the projects your teams are building. The more of that working set the Edge keeps resident, the more requests it serves from the local cache instead of reaching back to peers or durable storage. Size it for the warm-hit performance you want, not to a fixed figure. Going beyond the Build Cache target storage size gains nothing, though. The durable Build Cache holds long-tail retention and is often far larger (terabytes). The Edge cache, by contrast, is ephemeral: it repopulates from peers or durable storage after a restart. A volume larger than the durable Build Cache therefore only wastes capacity.

Sum only the rows that apply to your configuration. With external object storage and an external database, drop both of those rows. With an external database alone, drop the embedded-database row and keep the embedded-object-storage row.

If you produce more than 1 GB of Build Scan data a day, or retain Build Scan data for 30 days or more, provision more storage for the data volume.

If your volumes cannot be expanded later, add disk capacity upfront for future data growth.

Performance

For production workloads, storage volumes should exhibit SSD-class disk performance of at least 3000 IOPS (input/output operations per second). Most NFS based storage or desktop-class, non-SSD disk drives don’t provide this level of performance.

 Disk performance has a significant impact on Develocity performance. Network file systems (such as Amazon EFS) aren’t compatible with Develocity due to their performance characteristics.

Object Storage

Develocity administrators can store Build Scan® data and monitoring data such as metrics in an object storage service, such as Amazon S3, Google Cloud Storage, and Microsoft Azure Blob Storage. This can help performance in high-traffic installations by reducing the load on the database. Object storage services offer performance and cost advantages compared to database storage. If you deploy Develocity to a cloud provider or have an available internal S3-compatible object store, Gradle recommends using object-based storage for your installation. See Build Scan object storage in the Develocity Administration Manual for a description of the benefits and limitations.

Network Connectivity

Develocity requires network connectivity for periodic license validation.

 An installation of Develocity won’t start if it cannot connect to both registry.gradle.com and harbor.gradle.com.

It’s strongly recommended that production installations of Develocity are configured to use HTTPS with a trusted certificate.

Verify that your DNS points to your Develocity instance.

develocity.example.com A 12.34.56.78

You should verify that your DNS record works correctly before installing Develocity by running dig develocity.example.com or ping develocity.example.com in a console window.

For an airgap installation, you need a temporary machine with internet access to download the installation files. Transfer those files from that machine to your Develocity host.

Installation

If you are installing Develocity on a host without public network connectivity, follow the Airgap installation instructions.

Copy Files

Make sure that your Develocity license file is available on your host machine.

Install K3s

Install K3s and make it available to the current user:

curl -sfL https://get.k3s.io | sh -
sudo chown $UID /etc/rancher/k3s/k3s.yaml
mkdir -p "${HOME}/.kube"
ln -sf /etc/rancher/k3s/k3s.yaml "${HOME}/.kube/config"

Verify that you can interact with the K3s cluster:

kubectl get namespace

The expected output should be similar to this:

Output
NAME                STATUS   AGE
default             Active   1h
kube-system         Active   1h
kube-public         Active   1h
kube-node-lease     Active   1h
 For more information on K3s installation, see the K3s Quick-Start Guide and K3s Installation.

Install Helm

Develocity requires Helm version 3.13.x (or later) to install.

It’s recommended to use the latest version available as this will have all known security vulnerabilities addressed. This document describes the maximum version skew supported between Helm and Kubernetes.

 For more information on installing Helm (including alternate installation approaches), see Installing Helm.

Install Helm with the following command:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
 This guide covers installation of the gradle-enterprise-standalone chart. The Self-Hosted Kubernetes Installation Guide covers the gradle-enterprise chart.

Prepare a Helm Values File

Installation options for Develocity are depicted in a Helm values file.

Follow the instructions in the Standalone Helm Chart Configuration Guide and return to this document with a complete values.yaml file.

Install the Helm Chart

Develocity is distributed from the Develocity Helm repository.

Add the Develocity Helm repository to your Helm installation and fetch its contents into the local cache:

helm repo add gradle https://helm.gradle.com/
helm repo update gradle

Verify that the Develocity chart is accessible:

helm search repo gradle-enterprise

This will report the latest versions available for the two Develocity charts:

Output
NAME                                CHART VERSION       APP VERSION         DESCRIPTION
gradle/gradle-enterprise            2026.2.5            2026.2.5            Official Develocity chart for Kubernetes cluster installations
gradle/gradle-enterprise-standalone	2026.2.5            2026.2.5            Official Develocity chart for standalone installations

Install Develocity

Install Develocity by running:

helm install \
  --create-namespace --namespace develocity \(1)
  ge-standalone \(2)
  gradle/gradle-enterprise-standalone \(3)
  --values values.yaml \(4)
  --set-file global.license.file=./develocity.license (5)
1 This example uses develocity as the namespace, but it can be a custom name. If you use a custom name, update all other example commands accordingly.
2 This is the Helm release name. It’s used by Helm to identify the Develocity installation.
3 The Develocity chart to install, in this case, gradle/gradle-enterprise-standalone.
To install a specific version, use --version 2026.2.5.
4 The Helm values file with configuration values, including items such as the hostname.
5 The Develocity license file (if not already included in values file).

Start Develocity

Check that the Helm release is installed:

helm list --namespace develocity
Output
NAME            NAMESPACE           REVISION  UPDATED         STATUS    CHART                                  APP VERSION
ge-standalone   develocity          1         2026-09-10      deployed  gradle-enterprise-standalone-2026.2.5  2026.2.5

You can inspect the status of the Develocity Pods:

kubectl get pods --namespace develocity
Output
NAME                                               READY   STATUS    RESTARTS        AGE
edge-node-7d9c8b6f4d-x2kfp                         1/1     Running   0               3m39s
gradle-database-58f97cc888-sscxn                   2/2     Running   0               3m39s
gradle-embedded-object-storage-68d8956f98-c7gs9    1/1     Running   0               3m39s
gradle-enterprise-app-7fc5966df8-dw55g             1/1     Running   0               3m39s
gradle-enterprise-operator-dc7dbf46d-pp5hf         1/1     Running   0               3m39s
gradle-keycloak-5b975c469f-vw7ts                   1/1     Running   0               3m39s
gradle-monitoring-5f97675474-dszqv                 4/4     Running   0               3m38s
gradle-node-monitoring-7c4744dd6c-jmxkx            1/1     Running   0               3m39s
gradle-proxy-5c49c559ff-96w4q                      1/1     Running   0               3m39s
gradle-test-distribution-broker-77957b5988-5x5ph   1/1     Running   0               3m39s

Use the Develocity /ping endpoint to verify network connectivity.

Run the following command on any machine that needs to connect to Develocity:

curl -sw \\n --fail-with-body --show-error https://develocity.example.com/ping

The command returns {"status":"UP"} as the response message.

Once all Pods have a status of Running and the system is up and connected, you can interact with Develocity in a web browser. Its URL is the hostname you configured for the installation.

Develocity Sign in Page of Your Instance
Develocity Sign in Page of Your Instance

Develocity is now installed and running.

See Next Steps to learn more about Develocity.

Airgap Installation

In an airgap installation, the container images are preloaded into K3s. Helm is then configured so that no attempt is made to pull images from the outside world.

Airgap installations require a specific entitlement on your license. Please contact Gradle if you need an Airgap-enabled license.

Airgap installation involves downloading files, transferring them, installing supporting software, and running helm install.

 When installing Develocity, follow the installation manual for that version as the steps may have changed. See Develocity releases for information about the available versions.

We recommend you save all the files into a single transfer directory, so that it’s effortless to transfer to the host where you are installing Develocity. For example:

mkdir develocity-files && cd develocity-files

Download Required Files

Download K3s

Use the version overview matrix to identify the latest version of K3s supported by your version of Develocity.

Download the K3s images, binary, and install script:

curl -LO https://github.com/k3s-io/k3s/releases/download/v1.36.4+k3s1/k3s
curl -LO \
  https://github.com/k3s-io/k3s/releases/download/v1.36.4%2Bk3s1/k3s-airgap-images-amd64.tar.gz
curl -L -o install_k3s.sh https://get.k3s.io

If you are running Red Hat Enterprise Linux with SELinux enabled, download the K3s policy package:

🔍 SELinux policy package download

Lookup the latest version of the K3s SELinux Policy package:

K3S_SELINUX_DOWNLOAD_URL=$(curl -s https://api.github.com/repos/k3s-io/k3s-selinux/releases/latest | jq -r '.assets[] | select( .name | endswith("el8.noarch.rpm") ) | .browser_download_url') && echo $K3S_SELINUX_DOWNLOAD_URL
 You can view the versions available and find the download links on the K3s SELinux releases page.

Then download it:

curl -L -o k3s-selinux.el8.noarch.rpm $K3S_SELINUX_DOWNLOAD_URL

Download Helm

Use the compatibility matrix to identify the latest version of Helm supported by your version of Develocity.

Download the Helm binary:

curl -L -o helm-linux-amd64.tar.gz https://get.helm.sh/helm-v4.2.4-linux-amd64.tar.gz
 You can see all compatible Helm releases on the Helm releases page.

Download the Installation Bundle

Save your Develocity license to the transfer directory as develocity.license.

Download and verify the airgap bundle:

curl -LOJd @develocity.license \
  https://registry.gradle.com/airgap/gradle-enterprise-standalone-2026.2.5-bundle.tar.gz
curl -LOJd @develocity.license \
  https://registry.gradle.com/airgap/gradle-enterprise-standalone-2026.2.5-bundle.tar.gz.sha256
sha256sum -c gradle-enterprise-standalone-2026.2.5-bundle.tar.gz.sha256

If the checksum verification fails, check the contents of the downloaded files for error messages.
If the error message indicates that your license is invalid/expired/not airgap enabled, you will need to request an updated license file by contacting your customer success representative.

 Instead of running the above curl commands, you can download the airgap bundle by navigating to https://registry.gradle.com/airgap in your browser and following the instructions on the page.

Prepare a Helm Values File

Installation options for Develocity are depicted in a Helm values file.

Follow the instructions in the Standalone Helm Chart Configuration Guide and return to this document with a complete values.yaml file.

Before transferring files to your host, update your Helm values file in the transfer directory.

Transfer Files

Check that the transfer directory has the following files (additional files are fine):

  • k3s-airgap-images-amd64.tar.gz

  • k3s

  • install_k3s.sh

  • k3s-selinux.el8.noarch.rpm (only if you are running SELinux)

  • helm-linux-amd64.tar.gz

  • develocity.license

  • values.yaml

  • gradle-enterprise-standalone-2026.2.5-bundle.tar.gz

  • Optional: SSL certificates

After verifying that all the required files are present, transfer them to the host where you are installing Develocity.

Install K3s

Follow these instructions on the host where you are installing Develocity with your transferred files present in the current directory.

If you are running Red Hat Enterprise Linux with SELinux enabled, first install the necessary policy packages:

🔍 SELinux Policy installation

  1. Install the k3s-selinux package. This is a package that can be found in Red Hat Enterprise Linux’s default repository. Install this package on the airgapped server just such as you would install any other package. If your organization has an internal mirror of the Red Hat package repositories, you can run:

    sudo yum install -y k3s-selinux

  2. Install the K3s SELinux Policy package you downloaded:

    sudo yum install -y k3s-selinux.el8.noarch.rpm

Then install and set up K3s:

  1. Install K3s and make it available to the current user:

    sudo mkdir -p /var/lib/rancher/k3s/agent/images/ && \
  sudo cp k3s-airgap-images-amd64.tar.gz /var/lib/rancher/k3s/agent/images/
    (cd /var/lib/rancher/k3s/agent/images/ && sudo gunzip -f k3s-airgap-images-amd64.tar.gz)
    sudo cp k3s /usr/local/bin && sudo chmod a+rx /usr/local/bin/k3s
    sudo chmod a+rx ./install_k3s.sh && INSTALL_K3S_SKIP_DOWNLOAD=true ./install_k3s.sh
    sudo chown $UID /etc/rancher/k3s/k3s.yaml && \
  mkdir -p "${HOME}/.kube" && \
  ln -sf /etc/rancher/k3s/k3s.yaml "${HOME}/.kube/config"

  2. Verify that you can interact with the K3s cluster:

    kubectl get namespace
    Output
    NAME                STATUS   AGE
default             Active   1h
kube-system         Active   1h
kube-public         Active   1h
kube-node-lease     Active   1h

Install Helm

Run these steps on the host where you are installing Develocity, with the transferred files in the current directory.

To install Helm:

tar -zxvf helm-linux-amd64.tar.gz && sudo mv linux-amd64/helm /usr/local/bin/helm

Install Develocity

Follow these instructions on the host where you are installing Develocity with your transferred files present in the current directory.

Install Develocity:

tar zxvf gradle-enterprise-standalone-2026.2.5-bundle.tar.gz
sudo k3s ctr images import gradle-enterprise-standalone-2026.2.5-images.tar (1)
1 This command imports the images into K3s. 
helm install \
  --create-namespace --namespace develocity \(1)
  ge-standalone \(2)