Google GKE Kubernetes Installation Guide

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

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

You will need a Google Cloud project that has billing enabled for this tutorial. If you have a project you wish 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). Your nodes will be created using the Compute Engine default service account, so you also need permission to use it.

You can obtain these permissions using the following predefined roles:

Google Cloud Platform machines are provisioned with an external IP address but no hostname. Develocity is not accessible directly by IP, but there are services like nip.io that automatically map hostnames to IPs, so using your own hostname is not required.

If you want to access Develocity by a host name of your choosing (e.g. develocity.example.com), you will need the ability to create the necessary DNS record to route this name to the instance IP address.

You will be able to update this later. You can start with a public DNS name based on the IP address, and later reconfigure to use a custom hostname if desired.

Develocity installations have two database options:

By default, Develocity stores its data in a PostgreSQL database that is run as part of the application itself, with data being stored in a directory mounted on its host machine.

Develocity uses persistent volume claims for storing data, logs, and backups. If your cluster is configured with a default StorageClass, this StorageClass will be used.

In case that there is no default StorageClass configured or that you want to use different StorageClasses, you will need to provide the name of the StorageClass to be used for provisioning persistent volumes.

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

Some Pods are associated with multiple persistent volumes and for Kubernetes platforms with multiple availability zones, the Pods and their persistent volumes must be located in the same zone. In this case it’s recommended to 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.

It’s strongly recommended to use StorageClasses that allow persistent volume claim expansion if available. This makes expanding storage used as usage of Develocity increases straightforward.

Develocity requires network connectivity for periodic license validation.

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

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 3. A Google Cloud project with billing enabled. If your project doesn’t have a default zone, you need to set the zone (and region, which will often be set automatically from the zone) to the zone you wish to install Develocity in. If you don’t know which zone or region to select, consult Google Cloud’s region and zone documentation.

To easily 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 (note that 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 may 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. Please refer to the official documentation of these tools for installation instructions.

For this tutorial, we will use a Standard cluster with the default three nodes, using the e2-standard-4 machine type with 4 vCPUs and 16 GB 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.

You should then be able to see your cluster when running the following command:

Before installing Develocity, you need to create a static external IP for Develocity to use. While it is possible to configure the IP and hostname later by running helm upgrade with the updated Helm values file, it is easier to configure them now.

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 correctly 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 will work even with a hostname you don’t own (such as one from nip.io) as long as it redirects to a Google Cloud load balancer using your certificate.

We will use a managed certificate in this tutorial. If you want to use a custom SSL certificate instead, skip this step and follow the instructions in HTTP or HTTPS when creating 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:

Note that the certificate won’t 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 more details on what is configurable, see the Kubernetes Helm Chart Configuration Guide.

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

Second, download post-renderer resources into your current working directory:

Make sure that kustomize is available on your computer. If you have opted for Cloud Shell, kustomize is already pre-installed. 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 instead see an error like:

Consult 4. 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:

Secondly, check that all backends are healthy:

Once all pods have a status of Running and the backends are HEALTHY, the system is up, and you can interact with it by visiting its URL in a web browser. You can also visit the URL immediately once the backends are up and healthy, and will see a starting screen, which will then redirect to a Build Scan list once the app has started.

If the pods do not all start correctly, please see the troubleshooting section in the administration manual.

Once the pods are ready, it may take up to 60 minutes, but not usually that long, for Google to provision the managed SSL certificate. The status of the certificate can be checked by running:

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

Create two buckets using the gcloud CLI:

To interact with the Object Storage, some Develocity components requires access (read, write) to the previously created bucket with the role roles/storage.objectUser. Association between components and buckets can be described like this:

We can achieve those bindings using following commands:

Develocity must now be configured to use Google Cloud Storage. To do this, you must use the unattended configuration mechanism. This section will describe how to extend your Helm values file to include the correct unattended configuration block for Google 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:

We will refer to the hashed password, available inside the 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.