Deploy the simple-redis helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on the Digital Ocean Kubernetes Service using Pulumi, you first need to create a Kubernetes cluster in Digital Ocean. Once the cluster is up and running, you can deploy the `simple-redis` Helm chart to the cluster.

The Pulumi program below is written in TypeScript and performs the following steps:

1. **Create a Digital Ocean Kubernetes Cluster**: This is achieved using the `digitalocean.KubernetesCluster` resource from the Digital Ocean Pulumi provider. We specify the region, version, and node pool configuration for the Kubernetes cluster.

2. **Deploy the Helm Chart**: After the cluster is provisioned, Pulumi can deploy applications packaged as Helm charts directly to the cluster. The `kubernetes.helm.v3.Chart` resource from the Kubernetes Pulumi provider is used to deploy the `simple-redis` Helm chart.

Here's what the Pulumi program looks like:

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

// Step 1: Create a Digital Ocean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    // Replace with your desired cluster name and specifications
    name: "simple-redis-cluster",
    region: "nyc3",
    version: "latest",
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb",
        nodeCount: 1,
    },
});

// Step 2: Deploy the simple-redis Helm Chart to the Kubernetes cluster
const chart = new k8s.helm.v3.Chart("simple-redis-chart", {
    chart: "redis",
    // You might need to specify a repository URL if the chart is not in the default Helm repo
    // repo: "https://charts.helm.sh/stable",
    values: {
        // Specify Helm chart values here
    },
    // We're specifying the cluster and namespace for the Helm chart deployment
    // The provider property points to the cluster where resources should be created
    namespace: "default",
    fetchOpts: {
        // If the chart requires a specific version or is in a custom repository,
        // you can add those options here
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeConfigs[0].rawConfig }) });

// Export the cluster's kubeconfig and endpoint
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const clusterEndpoint = cluster.endpoint;
```

### Explanation:
- We import the necessary Pulumi packages for Digital Ocean and Kubernetes.
- We define a `digitalocean.KubernetesCluster` resource with a specific name, region, version, and node configuration.
- We define a `k8s.helm.v3.Chart` resource to deploy the `simple-redis` Helm chart. The chart's configuration (like version, values, or repository) can be customized in the `values` and `fetchOpts` properties.
- We create a Kubernetes provider (`k8s.Provider`) that uses the kubeconfig from the newly created Digital Ocean cluster. This provider is then passed to the Helm chart to ensure it's deployed on the right cluster.
- Finally, we export the kubeconfig and the endpoint of the Digital Ocean Kubernetes cluster so you can interact with your cluster using tools like `kubectl`.

Before running this program, ensure you have Pulumi installed and configured with the appropriate access tokens for Digital Ocean. Then you can invoke the Pulumi CLI to deploy this stack:

```bash
pulumi up
```

Once the deployment is successful, `pulumi up` will output the values for `kubeconfig` and `clusterEndpoint`, which you can use to interact with your Kubernetes cluster and check on your Redis deployment. Use the `kubectl` CLI tool with the exported kubeconfig to manage your Kubernetes resources:

```bash
kubectl --kubeconfig=<path-to-generated-kubeconfig> get pods
```

This will list the pods in your cluster, including those created by the `simple-redis` Helm chart.