Deploy the jx-app-sonarqube helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `jx-app-sonarqube` Helm chart on a DigitalOcean Kubernetes Service, you'll need to complete several steps, and we'll walk through these together in this guide. Pulumi provides a structured way to manage cloud resources using infrastructure as code, and with TypeScript, this process becomes flexible and familiar for JavaScript/TypeScript developers.

Here's an outline of what we'll be doing:

1. **Provision a DigitalOcean Kubernetes Cluster**: We'll create a Kubernetes cluster in DigitalOcean using the `digitalocean.KubernetesCluster` resource from the DigitalOcean Pulumi provider.

2. **Install the Helm Chart**: After our Kubernetes cluster is up and running, we'll deploy the `jx-app-sonarqube` Helm chart to the cluster using the `kubernetes.helm.v3.Chart` resource from the Kubernetes Pulumi provider.

### Prerequisites

- **Pulumi**: Make sure you have the Pulumi CLI [installed](https://www.pulumi.com/docs/get-started/install/).
- **DigitalOcean Token**: Ensure that you have a DigitalOcean personal access token that you'll use to authenticate with DigitalOcean.
- **Kubernetes Configuration**: Pulumi needs to be able to connect to the Kubernetes cluster to manage resources. By default, it uses the `kubeconfig` file on your local machine.

### Pulumi Program

Below is the TypeScript program that accomplishes the deployment:

```typescript
import * as digitalocean from "@pulumi/digitalocean";
import * as kubernetes from "@pulumi/kubernetes";
import * as pulumi from "@pulumi/pulumi";

// Step 1: Provision a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3",  // Choose the region that best fits your needs
    version: "latest",  // Use the latest version of Kubernetes
    nodePool: {
        size: "s-2vcpu-4gb", // Choose the size that fits your needs
        name: "default",
        nodeCount: 2, // Specify the number of nodes in the node pool
    },
});

// After the cluster is created, we can export the kubeconfig
export const kubeConfig = cluster.kubeConfigs[0].rawConfig;

// Step 2: Deploy the jx-app-sonarqube Helm chart to the cluster
// First, we use the kubeConfig we obtained from the cluster to configure our Kubernetes provider instance
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeConfig,
});

// Next, we declare our Helm chart resource
const sonarqubeChart = new kubernetes.helm.v3.Chart("sonarqube-chart", {
    chart: "sonarqube",
    version: "1.0.0", // Specify the version of the chart
    fetchOpts: {
        repo: "https://charts.oteemo.com", // The repo where the SonarQube chart can be found
    },
}, { provider: k8sProvider });  // Pass the provider to ensure it uses the correct kubeconfig

// Output the endpoint to access SonarQube
export const sonarqubeEndpoint = sonarqubeChart.getResourceProperty("v1/Service", "sonarqube-sonarqube", "status").apply(status => status.loadBalancer.ingress[0].ip);

```

### Explanation

- First, we import the necessary libraries from Pulumi for DigitalOcean and Kubernetes.
- We provision a new Kubernetes cluster on DigitalOcean using `digitalocean.KubernetesCluster`.
  - `region` specifies the location for our cluster.
  - `version` is set to `latest`, so we use the most recent supported Kubernetes version.
  - `nodePool` defines the details of our cluster nodes such as size, name, and count.
- We output `kubeConfig`, which contains the necessary information to connect to our Kubernetes cluster with kubectl or any Kubernetes client.
- Using the `kubeconfig`, we configure the Kubernetes provider. This provider is needed by Pulumi to interact with our new Kubernetes cluster.
- We deploy the `jx-app-sonarqube` Helm chart using `kubernetes.helm.v3.Chart`.
  - `chart` specifies the Helm chart we want to deploy, which is `sonarqube`.
  - `version` allows us to pin the chart to a specific version.
  - `fetchOpts.repo` is the URL of the Helm repo where the chart is stored.
- Finally, we export an endpoint that can be used to access the SonarQube UI once it's deployed. This is done by getting the load balancer's IP address of the SonarQube service from the chart's resources.

### Next Steps

After you have saved the above program to a file (e.g., `index.ts`), run it with the following Pulumi CLI commands:

1. Initialize a Pulumi project and stack:

```bash
pulumi new typescript --dir my-project
cd my-project
```

2. Copy and paste the TypeScript program into `index.ts`.

3. Install the necessary dependencies:

```bash
npm install @pulumi/digitalocean @pulumi/kubernetes @pulumi/pulumi
```

4. Run `pulumi up` to preview and deploy the changes:

```bash
pulumi up
```

After confirming, Pulumi will carry out the necessary steps to provision your DigitalOcean Kubernetes cluster and deploy SonarQube with Helm.

5. Access SonarQube:

Once the deployment is successful, you can use the `sonarqubeEndpoint` output to access SonarQube in a web browser. It can take a few minutes for the load balancer to assign an IP address and for SonarQube to start up.

If you have any further questions or need more guidance on managing your Pulumi projects, feel free to explore the [Pulumi documentation](https://www.pulumi.com/docs/).