Deploy the rollout-restart helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To accomplish the task of deploying a Helm chart to a Digital Ocean Kubernetes Service cluster using Pulumi, we will follow multiple steps. Firstly, we will create a Kubernetes cluster using the Digital Ocean provider for Pulumi. Then, we will deploy a Helm chart by using the `kubernetes` package which allows us to interface with Helm charts in our Pulumi program.

Here is a breakdown of these steps:

1. **Create a Kubernetes Cluster**: We use the `digitalocean.KubernetesCluster` resource to create a new Kubernetes cluster on Digital Ocean. This will be our target for deploying the Helm chart. We'll need to specify properties like the region, version of Kubernetes, node pool configuration, etc.

2. **Deploy a Helm Chart**: Once we have the cluster, we can deploy the Helm chart using `kubernetes.helm.v3.Chart` resource from the Kubernetes provider. This allows us to interact with Helm charts in a Kubernetes cluster managed by Pulumi.

Below is a TypeScript program that illustrates these steps. The program assumes that you have already set up your Pulumi account, installed the Pulumi CLI, and configured the necessary access tokens or environment variables for Digital Ocean.

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

// Create a DigitalOcean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc1", // Specify the region where you want to create the cluster
    version: "1.20.2-do.0", // Specify the version of Kubernetes
    nodePool: {
        name: "default",
        size: "s-1vcpu-2gb", // Size of the nodes in the node pool
        nodeCount: 2, // Number of nodes in the node pool
    },
});

// Get the kubeconfig from the newly created DO Kubernetes cluster.
const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Create a provider for the k8s package that uses the kubeconfig.
const k8sProvider = new k8s.Provider("do-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the rollout-restart Helm chart using the k8s provider.
const helmChart = new k8s.helm.v3.Chart("rollout-restart-helm-chart", {
    // Specify the chart, version, and repository or path here. For example:
    // chart: "nginx",
    // version: "1.16.0",
    // Specify Helm values
    values: {
        // Add Helm values here
        // image: { repository: "nginx", tag: "stable" },
        // service: { type: "LoadBalancer" },
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig.
export const kubeconfigOut = pulumi.secret(kubeconfig);
```

In this program, we define a new Kubernetes cluster on Digital Ocean with a specific region and Kubernetes version. The node pool is configured to have a certain size for each node and a specified number of nodes.

After the cluster is provisioned, we retrieve the kubeconfig required to communicate with the Kubernetes cluster. This kubeconfig is then used to create a new instance of a Kubernetes provider, which is required by Pulumi to manage resources within the Kubernetes cluster.

Next, we define a Helm chart resource. You will need to replace placeholder values like the chart, version, and values properties with the specifics of the "rollout-restart" Helm chart you want to deploy.

Lastly, we export the kubeconfig as a secret, which ensures that it isn't displayed in plaintext in any outputs.

Please replace the placeholders for the Helm chart deployment with actual values corresponding to the "rollout-restart" chart you are deploying. You might need to specify the correct Helm repository URL if it's a custom or non-standard chart.

Once you have prepared the script with your specific values, you can run your Pulumi program with the following commands:

```bash
pulumi up # Preview and deploy the changes
pulumi stack output kubeconfigOut # If you want to get the kubeconfig to use with kubectl
```

This will initiate the deployment process, and if everything is set up correctly, your Kubernetes cluster will be created on Digital Ocean, and the specified Helm chart will be deployed to it.