Google GKE Kubernetes Installation Guide

You can create an account if you do not already have one.

If you have purchased Develocity, you will already have a license file. Otherwise, you can request a Develocity trial license.

You will need a Google Cloud project that has billing enabled for this guide. If you have a project you want to use, ensure it has billing and the GKE APIs enabled. You can create a project by following this guide. To enable billing, follow these instructions for your project.

Your Google Cloud IAM user needs permission to create and manage various resources (GKE clusters, static IPs, managed certificates, or buckets). You also need permission to create resources in GKE clusters, including RBAC roles (which requires the container.roles.create permission). GKE creates your nodes with the Compute Engine default service account, so you also need permission to use that account.

You can obtain these permissions using the following predefined roles:

Google Cloud Platform machines are provisioned with an external IP address but no hostname.

To access Develocity by a hostname of your choosing, for example develocity.example.com, you must be able to create a DNS record. That record routes the name to the instance IP address.

Develocity installations have two database options:

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

By default, Develocity stores its data in a PostgreSQL database run as part of the application, storing database files in a directory mounted on its host machine. Although this is the default, a user-managed database is recommended.

Develocity uses persistent volume claims for storing data and backups. Develocity uses your cluster’s default StorageClass if it has one.

If no default StorageClass is configured, or you want to use a different one, provide the name of the StorageClass to use for provisioning persistent volumes.

Different StorageClasses can be specified for the different types of storage used.

Some Pods use multiple persistent volumes. On Kubernetes platforms with multiple availability zones, those Pods and their persistent volumes must sit in the same zone. In this case, use a StorageClass with a volumeBindingMode of WaitForFirstConsumer to ensure that all persistent volumes are provisioned in the same zone that the pod was scheduled in.

Where available, use StorageClasses that allow persistent volume claim expansion. Expanding storage is then straightforward as your Develocity usage grows.

Develocity requires network connectivity for periodic license validation.

Use HTTPS with a trusted certificate for production installations of Develocity.

When installing Develocity, you will need to provide a hostname, such as develocity.example.com.

You will be using the gcloud command line tool to provision and configure the Google Kubernetes Engine cluster. To install gcloud on your local machine, follow the instructions in the Google Cloud documentation.

To configure gcloud, run gcloud init and follow the initialization guide. You want to use the project you created or decided on in A Google Cloud Project With Billing Enabled. If your project does not have a default zone, set the zone and region to where you want to install Develocity. Setting the zone often sets the region automatically. If you do not know which zone or region to select, consult Google Cloud’s region and zone documentation.

To install a gcloud-managed version of kubectl, you can run:

You can also install kubectl through any other means. The Kubernetes documentation lists some of the most popular options. You only need to install kubectl, not any of the other tools listed there.

To authenticate with your GKE cluster, kubectl needs a GKE-specific plugin. If you are using an older Kubernetes version, this might not be necessary, but it does no harm.

To install the plugin, run:

This guide assumes that various common command line tools such as wget, curl and jq are already available on your host. Refer to the official documentation of these tools for installation instructions.

This guide uses a Standard cluster with 5 nodes, using the e2-standard-4 machine type with 4 vCPUs and 16 GiB of memory. See Resource requirements in the Self-Hosted Kubernetes Installation Guide for recommendations.

Name this cluster develocity. To create it, run:

This command will take a while to complete. It will automatically add and activate a kubectl configuration.

Confirm the cluster exists by running:

Before installing Develocity, you need to create a static external IP for Develocity to use. You can configure the IP and hostname later by running helm upgrade with the updated Helm values file, but configuring them now is simpler.

To create the static IP, run:

You can see the IP address used by the resource by running:

If you intend to use a custom hostname to access your Develocity instance, you now need to add the appropriate DNS records.

Add an A record for your hostname that points to the IP you created in the previous step. For example:

Verify that your DNS record works before installing Develocity, such as by using dig develocity.example.com.

You can provision and use a Google-managed trusted SSL certificate using Kubernetes manifests.

This guide uses a Google-managed certificate. To use a custom SSL certificate instead, skip this step. Follow the instructions in HTTP or HTTPS when you create your Helm values file below.

To provision a Google-managed SSL certificate, create a managed certificate resource on the cluster.

To apply this manifest, run the following command:

The certificate does not start provisioning until Develocity is installed.

To install Helm, run:

Create a Helm values file named values.yaml as shown below:

This file configures Develocity and its installation. For the full set of configuration options, see the Kubernetes Helm Chart Configuration Guide.

First, add the https://helm.gradle.com/ helm repository and update it:

Second, download the kustomization.zip file containing the post-renderer resources into your current working directory

Extract the downloaded ZIP file:

Give the script execute permissions:

Make sure that kustomize is available on your host. If you have opted for Cloud Shell, kustomize is already preinstalled. Otherwise, you can install it with the following command:

Then run helm install with the following command:

You should see output similar to this:

If you see this error instead:

Consult A Google Cloud IAM User With GKE Permissions.

You can see the status of Develocity starting up by examining its Pods.

Eventually the Pods should all report as Running:

Then check that all backends are healthy:

Once all Pods have a status of Running and the backends are HEALTHY, the system is up. Visit its URL in a web browser to interact with it. You can also visit the URL as soon as the backends are healthy. You then see a starting screen, which redirects to a Build Scan list once the app has started.

If the Pods do not all start correctly, see the support section in the administration manual.

Once the Pods are ready, Google provisions the managed SSL certificate. This can take up to 60 minutes, though it is usually faster. Check the certificate status by running:

Look for the Status, Certificate Status, and Domain Status fields in the output.

You will need permission to create and manage Cloud SQL instances and service accounts, and to add roles to service accounts.

You can obtain these permissions using the following built-in roles: roles/iam.serviceAccountAdmin, roles/resourcemanager.projectIamAdmin, and roles/cloudsql.admin.

If you cannot obtain roles/iam.serviceAccountAdmin and roles/resourcemanager.projectIamAdmin, ask someone who can create service accounts and add roles to them to complete Bind Kubernetes Service Account to Cloud SQL Permissions for you.

Before starting, review Develocity’s supported PostgreSQL versions and storage requirements.

To connect to the instance, you use the Cloud SQL Auth proxy running as a standalone service. Google’s documentation recommends running the proxy as a sidecar container, but that does not work for Develocity: some of its init containers need database access.

Add the following configuration snippet to your Helm values file:

If you skipped to this appendix from Prepare a Helm Values File while installing Develocity, continue at Install the gradle-enterprise Helm Chart.

Create two buckets using the gcloud CLI:

To use Object Storage, some Develocity components need read and write access to the buckets you created, through the roles/storage.objectUser role. Each component uses one of the two buckets:

Create those bindings with the following commands:

To configure Develocity to use Google Cloud Storage, you must use the unattended configuration mechanism. The steps below extend your Helm values file with the unattended configuration block for Google Cloud Storage.

First you need to create a minimal unattended configuration file. This requires you to choose a password for the system user and hash it. To do this, install develocityctl.

Then run the following command to hash your password, from standard-input (stdin), and write it to secret.txt:

This guide refers to the hashed password in secret.txt as «hashed-system-password».

To use your buckets, add the following to your Helm values file:

When adding things to your Helm values file, merge any duplicate blocks. Alternatively, you can use separate files and pass all of them with --values «file» when running Helm commands.

If you followed Using Cloud SQL as a Develocity User-Managed Database, you have some additional cleanup to do.

To delete your Cloud SQL instance, run:

To also delete the service account binding you created, run:

If you followed Using Google Cloud Storage as User-Managed Object Storage, you have some additional cleanup to do.

To delete your Cloud Storage buckets, run:

To also delete the service account bindings you created, run: