Deploy the v3-backend helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart to a Kubernetes cluster on Digital Ocean, we'd typically follow these steps:

1. **Create a Kubernetes Cluster**: First, set up the DigitalOcean Kubernetes Service using the `digitalocean.KubernetesCluster` resource.
2. **Configure Kubernetes Provider**: After the cluster creation, configure the Kubernetes provider to point to the newly created cluster.
3. **Deploy a Helm Chart**: Finally, use the `kubernetes.helm.v3.Chart` resource to deploy the Helm chart to the cluster.

Below is a TypeScript program that illustrates how to do this using Pulumi:

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

// Step 1: Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("v3-backend-cluster", {
    region: digitalocean.Regions.NYC1,
    version: "latest", // Use the latest version available for the Kubernetes cluster
    nodePool: {
        name: "v3-backend-worker-pool",
        size: digitalocean.DropletSlugs.DropletS1VCPU2GB,
        nodeCount: 2, // Specify the number of worker nodes
    },
});

// Step 2: Configure the Kubernetes provider to use the kubeconfig from the created cluster
const k8sProvider = new k8s.Provider("v3-backend-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Step 3: Deploy the Helm chart on the DigitalOcean Kubernetes cluster
const helmChart = new k8s.helm.v3.Chart("v3-backend-chart", {
    chart: "v3-backend",
    version: "1.0.0", // Replace with the desired version of your Helm chart
    // Add any required configuration values for the Helm chart here
    values: {
        // Example configuration:
        // replicaCount: 2,
        // image: {
        //     repository: "your_image_repository",
        //     tag: "your_image_tag",
        // },
    },
}, { provider: k8sProvider });

// Export the public IP address of the load balancer, if applicable
// This assumes your Helm chart creates a service of type LoadBalancer
// that exposes the application to the internet
const frontendService = helmChart.getResource("v1/Service", "v3-backend", "v3-backend-service");
export const frontendIp = frontendService.status.apply(status => status.loadBalancer?.ingress[0].ip);
```

Let's break down what the code does:

- **Creating the Kubernetes Cluster**: 
    - We define a DigitalOcean Kubernetes cluster resource with a specified region and version. 
    - We use the node pool configuration to specify the size of the droplet and the number of nodes for our worker pool.

- **Configuring the Kubernetes Provider**: 
    - Using the kubeconfig that the DigitalOcean cluster resource provides, we set up the Kubernetes provider.
    - This step is crucial because it allows our Pulumi program to interact with the newly created Kubernetes cluster.

- **Deploying the Helm Chart**:
    - We define a Helm chart resource pointing to our `v3-backend` Helm chart.
    - We specify the version of the Helm chart and provide any required configuration values through the `values` argument.

- **Exporting the Service IP (Optional)**:
    - If your Helm chart includes a Kubernetes Service of type LoadBalancer, the program tries to fetch and export the public IP address exposed by this service.
    - The public IP address can then be used to access your application.

Finally, the cluster's external IP address (assuming the Helm chart exposes one) is exported as a stack output, which can be accessed once the deployment is complete. This step presupposes that your Helm chart creates a service that is exposed via a LoadBalancer. If your service type is different, such as `ClusterIP` or `NodePort`, you'll need to handle external exposure accordingly and modify the export statement.
  
Keep in mind that you should replace placeholders (`your_image_repository`, `your_image_tag`, the Helm chart version, etc.) with actual values corresponding to your Helm chart.

To run this Pulumi program, save it to a file named `index.ts`, and ensure you have Pulumi installed along with the necessary provider plugins (`@pulumi/digitalocean` and `@pulumi/kubernetes`). You'll also need to have access to DigitalOcean API credentials configured for Pulumi to create and manage resources in your DigitalOcean account.

Run the command `pulumi up` in the same directory as your saved TypeScript file to preview and deploy your infrastructure. Pulumi will execute the plan and, after confirmation, provision the Kubernetes cluster and deploy your v3-backend Helm chart.