This tutorial will show how to run Gradle Enterprise on the Google Compute Engine.

This tutorial requires using Gradle Enterprise 2022.3.1 or later.

You can complete this tutorial in:

  • 10 minutes (read the tutorial)

  • 30 minutes (read the tutorial and perform the installation)

Gradle Enterprise can be installed as a standalone installation on a single server. It can also be installed in an existing Kubernetes cluster, including Google Kubernetes Engine, as shown in our Google Kubernetes Engine installation tutorial. This tutorial shows how to set up a standalone installation on a Google Compute Engine instance.

Gradle Enterprise can be installed on most modern Linux servers. The majority of this tutorial is a quick start guide to creating and minimally configuring a Compute Engine instance in Google Cloud for a Gradle Enterprise installation. If you already have Google Compute Engine expertise and are able to provision an instance, you may wish to skip straight to the Gradle Enterprise installation instructions.

Other installation tutorials

Google Cloud

Prerequisites

1. A Google Cloud account

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

2. A Gradle Enterprise license

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

3. A Google Cloud project with billing enabled

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 Compute Engine APIs enabled. You can create a project by following Google’s guide. To enable billing, follow these instructions for your project.

If you are using a new project, you may be asked to enable various APIs when running commands. Go ahead and do this, they are necessary for the tutorial.

4. A Google Cloud IAM user with Compute Engine permissions

If you are the project owner, you likely have all permissions already.

Your Google Cloud IAM user needs permission to create and manage Compute Engine instances, alter firewall rules, and create and manage static IPs. Your instance will be created using the Compute Engine default service account, so you need permission to use it.

You can obtain these permissions using the following built-in roles: roles/compute.admin and roles/iam.serviceAccountUser for the Compute Engine default service account.

If you choose to follow our Cloud SQL appendix, you will need the permissions described in it, too.

5. Hostname (optional)

Google Cloud Platform machines are provisioned with an external IP address but no hostname. Gradle Enterprise 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 Gradle Enterprise by a host name of your choosing (e.g. ge.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.

Setting up your shell environment

You need to use the gcloud CLI tool to create Google Cloud resources and install Gradle Enterprise. You can either install it locally, or use Google Cloud’s Cloud Shell, which comes with gcloud preinstalled and mostly preconfigured.

You can use Cloud Shell via SSH by following these instructions. This requires installing gcloud locally, and then using it to SSH into Cloud Shell, where you would run the tutorial’s commands.
We assume you are using bash as your shell, although any shell that is fairly compatible (e.g. zsh) should work without much trouble.

Keep in mind the version requirements from the Gradle Enterprise installation manual. The rest of the requirements in the manual are either not applicable or fulfilled later in this tutorial, but the section is worth a read, especially if you want to customize your infrastructure.

Some tools need to be installed on your Compute Engine VM. You will install those later.

When files are referred to in this tutorial, they are assumed to be on the machine you are running the command on. When running commands on your VM, any necessary files will be explicitly uploaded. If you are using Cloud Shell, you will need to upload any referenced files to the shell machine by following the Cloud Shell documentation.

If you decided to use Cloud Shell, complete 2. Configure gcloud (unless you already have the project and zone configured) and then skip to Creating a Google Compute Engine VM.

1. Install gcloud

You will be using the gcloud command line tool to provision and configure Gradle Enterprise’s VM. To install gcloud on your local machine, follow the instructions in the Google Cloud documentation.

2. Configure gcloud

gcloud configurations are not saved by default by Cloud Shell. To save your configuration, follow Google’s instructions.

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 Gradle Enterprise in. If you don’t know which zone or region to select, consult Google Cloud’s region and zone documentation. You usually want to use the zone that is geographically closest to your Gradle Enterprise instance’s users.

Creating a Google Compute Engine VM

In this section you will create a Google Compute Engine instance to run Gradle Enterprise.

If you’re using Cloud Shell, remember to run these commands there.

1. Create an external IP

Before creating your VM instance, you need to create a static external IP for Gradle Enterprise to use. While it’s possible to configure the IP and hostname later by running helm upgrade with the updated Helm values file and updating your VM, it is easier to configure them now.

This step isn’t strictly necessary; Compute Engine instances are automatically assigned an external IP. However, this IP will change whenever you restart the instance, making maintaining DNS records and the Helm values configuration difficult.

To create the static IP, run:

$ gcloud compute addresses create ge-static-ip

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

$ gcloud compute addresses describe ge-static-ip --format='value(address)'
The static external IP resource is managed separately from your VM. It will not be automatically deleted if the VM using it is deleted.

2. Create a virtual machine

Looking at the requirements in the installation manual, let’s create an instance with 250 GiB of storage, 4 CPUs and 16 GiB of RAM.

If you do not have a preferred operating system, gcloud will use debian-11 as a base operating system. If you prefer a different operating system, choose one appropriate for your environment after consulting the Gradle Enterprise operating system requirements.

For this tutorial, let’s name the instance gradle-enterprise and define our settings by entering the following command in the terminal:

$ gcloud compute instances create gradle-enterprise \
    --address=$(gcloud compute addresses describe ge-static-ip --format='value(address)') \
    --custom-cpu=4 \
    --custom-memory=16GB \
    --boot-disk-size=250GB
If you have a preferred supported operating system, you can pass it as a parameter to the create command as described here. A list of public base images can be found here.
The majority of the disk space is used by Gradle Enterprise’s embedded database. If you use a user-managed database (such as Cloud SQL, as described in an appendix), you can reduce the boot disk size to 50GB.

You may see a warning about the disk size being larger than the image size. This is not an issue if you are using the default debian-11 operating system or any other public image.

3. Set up firewall rules

On the Google Compute Platform, firewall rules are set at project level. There are some ports you will need to expose to access Gradle Enterprise. These are:

  • Port 80 for HTTP

  • Port 443 for HTTPS

If Gradle Enterprise is using HTTPS, as it does by default, you don’t need to expose port 80. However, if you do, Gradle Enterprise will automatically redirect any HTTP traffic to HTTPS.

Create the firewall rules via the following commands:

$ gcloud compute firewall-rules create ge-http --allow tcp:80 --description="GE HTTP"
$ gcloud compute firewall-rules create ge-https --allow tcp:443 --description="GE HTTPS"

You can check these have been set correctly by running the following command:

$ gcloud compute firewall-rules list
NAME                    NETWORK  DIRECTION  PRIORITY  ALLOW                         DENY
default-allow-icmp      default  INGRESS    65534     icmp
default-allow-internal  default  INGRESS    65534     tcp:0-65535,udp:0-65535,icmp
default-allow-rdp       default  INGRESS    65534     tcp:3389
default-allow-ssh       default  INGRESS    65534     tcp:22
ge-http                 default  INGRESS    1000      tcp:80
ge-https                default  INGRESS    1000      tcp:443

4. Configure the hostname

If you intend to use a custom hostname to access your Gradle Enterprise 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 step 1 of this tutorial. For example:

ge.example.com A 34.110.226.160

You should verify that your DNS record works correctly before installing Gradle Enterprise, such as by using dig ge.example.com.

Google Cloud has its own Cloud DNS service, which can be used for this tutorial. However, there is no integration with Google Compute Engine that makes it preferable to other DNS services.

It is not possible to use an IP address directly as the Gradle Enterprise hostname. If you do not wish to set up a permanent DNS record at this time, you can instead use a service like nip.io to provide one based on the IP address. Any of the dash-based naming schemes on the nip.io web page should work, but the following command will generate a useful short name tied to that IP address (set IPADDR to the static IP address you created earlier):

$ GE_IP_ADDR=$(gcloud compute addresses describe ge-static-ip --format='value(address)')

$ echo "gradle-enterprise-$(printf '%02x' $(echo ${GE_IP_ADDR//./ })).nip.io"
gradle-enterprise-226ee2a0.nip.io

gradle-enterprise-226ee2a0.nip.io can then be used as the hostname.

You can run Gradle Enterprise behind a cloud load balancer such as Cloud Load Balancing. If you do this, you should generally use /ping for the load balancer’s health check. It will respond as healthy when Gradle Enterprise is capable of handling requests, even if that is limited to showing the interactive starting page while the instance is starting.

This may be unwanted for highly available installations using the load balancer to manage failover. If you are installing Gradle Enterprise in a highly available setup, we recommend submitting a ticket at support.gradle.com for assistance.

You can use a Google-managed SSL certificate by configuring Gradle Enterprise to use external SSL termination, putting your Gradle Enterprise installation behind a Cloud Load Balancer, and terminating SSL at the load balancer using the managed certificate. Consult the Cloud Load Balancer managed SSL certificate documentation for more details.

Installing Gradle Enterprise

In this section you will install Gradle Enterprise on your newly created instance. For full details on installation options, please see the Gradle Enterprise Helm Standalone Installation Manual.

1. Prepare a Helm values file

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

values.yaml
global:
  hostname: ge.example.com (1)
1 Use the hostname you decided on in 4. Configure the hostname or substitute it later as shown below.
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.

This file configures Gradle Enterprise and its installation. You can find more details on what is configurable in the Gradle Enterprise installation manual’s Helm configuration section.

If you want to use a nip.io hostname as described in 4. Configure the hostname, you can substitute it into the Helm values file by running:

$ GE_IP_ADDR=$(gcloud compute addresses describe ge-static-ip --format='value(address)')

$ GE_HOSTNAME="gradle-enterprise-$(printf '%02x' $(echo ${GE_IP_ADDR//./ })).nip.io"

$ sed -i "s/ge.example.com/${GE_HOSTNAME}/g" path/to/values.yaml
On macOS, you may need to replace -i with -i '' when using sed.
If you want to provide an SSL certificate instead of having Gradle Enterprise generate a self-signed one, follow the instructions in the installation manual.
If you want to use a Cloud SQL PostgreSQL instance as your database instead of the embedded database, follow Using Cloud SQL as a Gradle Enterprise user-managed database.

2. Copy configuration files to the instance

Copy the Helm values file you created and your Gradle Enterprise license file to the instance:

$ gcloud compute scp path/to/values.yaml gradle-enterprise:~
$ gcloud compute scp path/to/gradle-enterprise.license gradle-enterprise:~

If you are using a custom SSL certificate, copy the certificate and key files to the instance as well.

3. Install K3s and Helm on your VM

SSH into the instance:

$ gcloud compute ssh gradle-enterprise

This will ask you for a passphrase (which you will need to remember for next time you want to access the instance) and generate an SSH key. It will then ask you for the passphrase again, and if successful will give you command line access to the machine.

Once you’re on the machine, 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 -s /etc/rancher/k3s/k3s.yaml "${HOME}/.kube/config"

Then install Helm:

$ curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
If you’re following the Cloud SQL appendix, you should do Deploy the Cloud SQL Proxy now.

4. Install the gradle-enterprise-standalone Helm chart

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

$ helm repo add gradle https://helm.gradle.com/
$ helm repo update gradle
If you’re using an older Helm version (which Cloud Shell may), you may need to run helm repo update instead of helm repo update gradle.

Then run helm install with the following command:

$ helm install \
    --create-namespace --namespace gradle-enterprise \
    ge-standalone \
    gradle/gradle-enterprise-standalone \
    --values ./values.yaml \(1)
    --set-file global.license.file=./gradle-enterprise.license (2)
1 The Helm values file you created in 1. Prepare a Helm values file and uploaded in 2. Copy configuration files to the instance.
2 The license you obtained in 2. A Gradle Enterprise license and uploaded in 2. Copy configuration files to the instance.

You should see output similar to this:

NAME: ge-standalone
LAST DEPLOYED: Wed Jul 13 04:08:35 2022
NAMESPACE: gradle-enterprise
STATUS: deployed
REVISION: 1
TEST SUITE: None

5. Wait for Gradle Enterprise to start

You can see the status of Gradle Enterprise starting up by examining its pods.

$ kubectl --namespace gradle-enterprise get pods
NAME                                              READY   STATUS              RESTARTS   AGE
gradle-enterprise-operator-76694c949d-md5dh       1/1     Running             0          39s
gradle-database-65d975cf8-dk7kw                   0/2     Init:0/2            0          39s
gradle-build-cache-node-57b9bdd46d-2txf5          0/1     Init:0/1            0          39s
gradle-proxy-0                                    0/1     ContainerCreating   0          39s
gradle-metrics-cfcd8f7f7-zqds9                    0/1     Running             0          39s
gradle-test-distribution-broker-6fd84c6988-x6jvw  0/1     Init:0/1            0          39s
gradle-keycloak-0                                 0/1     Pending             0          39s
gradle-enterprise-app-0                           0/1     Pending             0          39s

Eventually the pods should all report as Running:

$ kubectl --namespace gradle-enterprise get pods
NAME                                               READY   STATUS    RESTARTS   AGE
gradle-enterprise-operator-76694c949d-md5dh        1/1     Running   0          4m
gradle-proxy-0                                     1/1     Running   0          3m
gradle-database-65d975cf8-dk7kw                    2/2     Running   0          3m
gradle-enterprise-app-0                            1/1     Running   0          3m
gradle-metrics-cfcd8f7f7-zqds9                     1/1     Running   0          3m
gradle-test-distribution-broker-6fd84c6988-x6jvw   1/1     Running   0          3m
gradle-build-cache-node-57b9bdd46d-2txf5           1/1     Running   0          4m
gradle-keycloak-0                                  1/1     Running   0          3m

Once all pods have a status of Running, the system is up and can you can interact with it by visiting its URL in a web browser.

You can also visit the URL immediately, and will see a starting screen, which will then redirect to a Build Scan list once the app has started.

Gradle Enterprise uses a self-signed SSL certificate by default, so most browsers will warn about an untrusted certificate. To avoid this, use a managed SSL certificate as described in 4. Configure the hostname or use a custom trusted SSL certificate as described in 1. Prepare a Helm values file.

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

6. Update the system user password

Unless you have configured the system password using unattended configuration, Gradle Enterprise will create a system user with elevated permissions and a default password. This is insecure, and you should change the password as soon as possible.

To change the password, simply visit Gradle Enterprise using a web browser and sign in (using the "Sign In" button at the top right of the page) with the system user (username system, password default). You will then be prompted to select a new password for the system user account. You should record the new password and keep it secret.

It is recommended to not use the system user account regularly. Instead, real administrator user accounts should be created by configuring access control (see the next section).

Using Gradle Enterprise

Many features of Gradle Enterprise, including access control, database backups, and Build Scan retention can be configured in Gradle Enterprise itself, once it is running. The administration manual walks you through the various features you can configure post-installation - you should give the section a read.

For instructions on how to start using Gradle Enterprise in your builds, consult the Getting Started with Gradle Enterprise guide.

Deleting your instance

Further reading

Appendix A: Using Cloud SQL as a Gradle Enterprise user-managed database

Gradle Enterprise can use a user-managed database instead of using its own embedded database. This can have a number of benefits, including easier resource scaling (and even autoscaling), easier backup and snapshot management, and failover support. For details on the pros and cons of using a user-managed database with Gradle Enterprise, see the database section of the installation manual. This appendix will walk you through using a Google Cloud SQL PostgreSQL instance as your database.

For a detailed explanation of the advantages and disadvantages of using a user-managed database with Gradle Enterprise, see the database type section of the installation manual.

Obtain the required permissions

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, roles/iam.serviceAccountUser and roles/cloudsql.admin.

If getting roles/iam.serviceAccountAdmin and roles/resourcemanager.projectIamAdmin is difficult, you can have someone else who has permission to create service accounts and add roles to them complete 1. Create a Google Cloud service account with Cloud SQL permissions. You still need roles/iam.serviceAccountUser for that service account.

You will also need to ensure that cloudresourcemanager.googleapis.com is enabled for your project.

Set up a Cloud SQL instance

Before starting, it is a good idea to review Gradle Enterprise’s supported Postgres versions and storage requirements.

1. Decide on a root username and password

Decide on a root password for the database instance. We will refer to it as «db-root-password». This is the password you will use for your database connection, so save it somewhere secure.

The superuser is only used by Gradle Enterprise to set up the database and create migrator and application users. You can avoid using the superuser from Gradle Enterprise by setting up the database yourself, as described in the database configuration section of Gradle Enterprise’s installation manual. Please contact Gradle support for help with this.

2. Create the Cloud SQL instance

Create the Cloud SQL instance:

$ gcloud sql instances create gradle-enterprise-database \
    --database-version=POSTGRES_14 \
    --cpu=2 \
    --memory=8GB \
    --storage-size=250GB \
    --require-ssl \
    --database-flags=max_connections=200 \
    --zone=$(gcloud config get compute/zone) \(1)
    --root-password=«db-root-password»
1 The zone where you created your Compute Engine VM.

This will create an instance with 2 CPUs and 8 GB of RAM, with 250 GB of storage, without any replication. The storage will automatically increase if necessary, but will not decrease.

Cloud SQL databases are not backed up by default, but this can be easily enabled. See the backup documentation.
Consult the command reference to see all options available when creating the Cloud SQL instance.
It is possible to create an instance with a private (VPC-only) IP. Consult this documentation for details. The connection method we use will still work with a private IP, with some modifications described in the Cloud SQL proxy docs.

3. Create a database

Cloud SQL instances don’t come with a database by default, so you need to create one for Gradle Enterprise:

$ gcloud sql databases create gradle_enterprise --instance=gradle-enterprise-database

Create and use a service account with Cloud SQL permissions

To enable our Compute Engine instance to access our Cloud SQL instance, we will configure our Compute Engine instance to use a service account with the roles/cloudsql.client role.

If for some reason you can’t change the instance’s service account or add the CloudSQL client role to it, you can create a JSON key and mount it to the Cloud SQL deployment. You will need to alter the deployment manifest in Deploy the Cloud SQL Proxy according to GKE’s documentation.

1. Create a Google Cloud service account with Cloud SQL permissions

You need to create a Google Cloud service account to authenticate with Cloud SQL with:

$ gcloud iam service-accounts create ge-service-account \
    --display-name="Gradle Enterprise Service Account"
$ gcloud projects add-iam-policy-binding $(gcloud config get project) \
    --member="serviceAccount:ge-service-account@$(gcloud config get project).iam.gserviceaccount.com" \
    --role="roles/cloudsql.client"

2. Use the service account for your VM

To use your new service account, you will set it as the service account for your Compute Engine instance:

$ gcloud compute instances stop gradle-enterprise
$ gcloud compute instances set-service-account gradle-enterprise \
    --service-account "ge-service-account@$(gcloud config get project).iam.gserviceaccount.com" \
    --scopes=https://www.googleapis.com/auth/cloud-platform
$ gcloud compute instances start gradle-enterprise

Configure Gradle Enterprise to use your Cloud SQL instance

Add the following configuration snippet to your Helm values file:

values.yaml
database:
  location: user-managed
  connection:
    host: gradle-database-proxy
    port: 5432
    databaseName: gradle_enterprise
    params: "?ssl=false"
  credentials:
    superuser:
      username: postgres
      password: «db-root-password»
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.
The superuser is only used to set up the database and create migrator and application users. You can avoid using the superuser by setting up the database yourself, as described in the database configuration section of Gradle Enterprise’s installation manual. Please contact Gradle support for help with this.
This embeds your database superuser credentials in your Helm values file, meaning it must be kept secure. If you prefer to provide the credentials as a Kubernetes secret, consult Gradle Enterprise’s database configuration instructions.
While we recommend completing this appendix before installing the Gradle Enterprise Helm chart, it is possible to do it afterwards and then update the the Helm release. To do this, follow the instructions in the installation manual.
Switching to a user-managed database after installing Gradle Enterprise will result in the lose of any data stored prior to the switch. This may not be an issue for new installations. If it is, follow the user-managed database migration guide.

Deploy the Cloud SQL Proxy

To connect to the instance, you will use the Cloud SQL Auth proxy running as a standalone service. While the official documentation recommends running the proxy as a sidecar container, this does not work for Gradle Enterprise because some of our init-containers require database access.

We will be using your locally-installed k3s cluster to run and manage the proxy. This integrates best with Gradle Enterprise, and avoids using yet another service management tool. This step must be done after 3. Install K3s and Helm on your VM but before 4. Install the gradle-enterprise-standalone Helm chart.

First, get the connection name of your Cloud SQL instance by running:

$ gcloud sql instances describe gradle-enterprise-database --format='value(connectionName)'

We will refer to this as «connection-name»

Then deploy the proxy and create a service for it by applying the following manifest to the k3s cluster on your VM:

database-proxy.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: gradle-enterprise
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradle-database-proxy
  namespace: gradle-enterprise
spec:
  selector:
    matchLabels:
        app: gradle-enterprise
        component: database-proxy
  template:
    metadata:
      labels:
        app: gradle-enterprise
        component: database-proxy
    spec:
      containers:
      - name: cloud-sql-proxy
        image: gcr.io/cloudsql-docker/gce-proxy:latest (1)
        ports:
        - containerPort: 6543
        command: (2)
          - "/cloud_sql_proxy"
          - "-instances=«connection-name»=tcp:0.0.0.0:6543" (3)
        securityContext:
          runAsNonRoot: true
---
apiVersion: v1
kind: Service
metadata:
  name: gradle-database-proxy
  namespace: gradle-enterprise
spec:
  selector:
    app: gradle-enterprise
    component: database-proxy
  ports:
  - port: 5432
    targetPort: 6543
1 This uses the latest version of the Cloud SQL proxy. It is recommended to use a specific version for production environments. See https://github.com/GoogleCloudPlatform/cloudsql-proxy.
2 The arguments to the Cloud SQL proxy.
3 The connection name of your Cloud SQL instance, which you can substitute as shown below.
Once version 2 of the Cloud SQL proxy is released, you will need to change the arguments in accordance with their migration guide. You can view the released versions by visiting the image url in your browser.

To easily apply this manifest while substituting in the correct «connection-name», run (verbatim):

$ CONNECTION_NAME=$(gcloud sql instances describe gradle-enterprise-database --format='value(connectionName)')

$ sed "s/«connection-name»/${CONNECTION_NAME}/g" | kubectl apply -f -

And then paste the above manifest (verbatim) into stdin.

When writing or pasting to a shell’s stdin, use EOF (usually ctrl+d) to end the input.
Consult the GKE and Cloud SQL tutorial and Connect from GKE documentation for more details on using the Cloud SQL proxy from kubernetes. These are GKE-specific guides, though, so some instructions (mostly around using service accounts) don’t apply here. For details on using a service account with the Compute Engine, consult the Connect from Compute Engine documentation.

Appendix B: Teardown and Cleanup

This appendix will walk you through tearing down Gradle Enterprise and deleting any resources created by following this tutorial.

To delete your instance, run:

$ gcloud compute instances delete gradle-enterprise

This will inform you that the instance and attached storage will be destroyed, and ask if you are sure. Choose “Yes” to continue.

To delete the static IP address, run:

$ gcloud compute addresses delete ge-static-ip

To delete the firewall rules you created, run:

$ gcloud compute firewall-rules delete ge-http
$ gcloud compute firewall-rules delete ge-https

If you’re using other resources, like a Cloud SQL database, remember to delete them too. Cloud SQL teardown instructions are in the section below.

Cloud SQL

If you followed Using Cloud SQL as a Gradle Enterprise user-managed database, you have some additional cleanup to do.

Deleting a Cloud SQL instance also deletes any automated backups of its database.

To delete your Cloud SQL instance, run:

$ gcloud sql instances delete gradle-enterprise-database

To also delete the service account you created, run:

$ gcloud iam service-accounts delete \
    "ge-service-account@$(gcloud config get project).iam.gserviceaccount.com"
This must be done after deleting your Compute Engine instance.
If you didn’t get full permissions for service account management, you may not be able to do this yourself.