Deploy the sonatype-nexus3 helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Deploying a Helm chart on the Digital Ocean Kubernetes Service with Pulumi involves several steps:

1. Create a Digital Ocean Kubernetes cluster (DOKS).
2. Install and configure the Helm chart.

Let's go through these steps in a Pulumi program written in TypeScript.

### Setting up Digital Ocean Kubernetes Service

To create a Digital Ocean Kubernetes cluster, you'll need to use the `digitalocean.KubernetesCluster` resource. This resource allows you to provision and manage Kubernetes clusters in Digital Ocean. You'll need to specify the region, the size of the droplets you want to use, the number of nodes, and the Kubernetes version.

### Installing the Helm Chart

Once the cluster is set up, you can use the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider to deploy Helm charts. This resource is an abstraction that lets Pulumi interact with Helm. You will need to specify the chart you want to install, the repository where the chart is located, and any custom values you want to apply to the chart.

Below is a Pulumi program that creates a Digital Ocean Kubernetes cluster and installs the Sonatype Nexus 3 Helm chart onto it:

```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("nexus-cluster", {
    region: "nyc3",
    version: "1.22.5-do.0", // use a version available in your DigitalOcean region
    nodePool: {
        size: "s-2vcpu-2gb", // adjust the size as per your requirements
        name: "default",
        nodeCount: 2,
    },
});

// Step 2: Use the kubeconfig from the generated cluster to interact with it
const provider = new kubernetes.Provider("do-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Step 3: Deploy the Sonatype Nexus3 Helm chart
const nexusChart = new kubernetes.helm.v3.Chart("nexus", {
    chart: "sonatype-nexus",
    version: "5.3.0", // specific chart version, check for the latest version in Helm repository
    fetchOpts: {
        repo: "https://sonatype.github.io/helm3-charts/", // the repository where the chart is located
    },
}, { provider });

// Export the cluster's kubeconfig and the Nexus service endpoint
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const nexusEndpoint = pulumi.interpolate`http://${nexusChart.getResource("v1/Service", "nexus-sonatype-nexus").status.loadBalancer.ingress[0].ip}`;
```

In this program, you first create a Kubernetes cluster in the `nyc3` region, choosing the Droplet size and number of nodes according to your needs. Then, create a `Provider` with the kubeconfig of the newly created cluster to manage the Kubernetes resources.

Lastly, you deploy the Sonatype Nexus3 Helm chart using the `kubernetes.helm.v3.Chart` resource, specifying the chart name, version, and repository URL.

The program then exports the kubeconfig for interacting with the cluster outside of Pulumi and the endpoint of the Nexus service, which will typically be the external IP that you can use to access the Nexus UI once it's deployed.

To run the program:

1. Set up Pulumi with your Digital Ocean access token.
2. Save this program in a file with a `.ts` extension (e.g., `index.ts`).
3. Run `pulumi up` to create the resources.

Remember that deploying cloud resources can incur costs. Always ensure you understand the pricing model for the services you're using and clean up resources with `pulumi destroy` if they're no longer needed.