Deploy the multicloud helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Kubernetes cluster with Pulumi is a straightforward process that can be accomplished with the `Chart` resource from the Pulumi Kubernetes provider. This resource allows you to deploy Helm charts similarly to how you would use the `helm` CLI.

Below is a TypeScript program that demonstrates how to deploy a Helm chart to a Kubernetes cluster managed by cloud providers like AWS, Azure, or Google Cloud. For simplicity, I'll show you how to deploy the Helm chart to a previously provisioned Kubernetes cluster. I will assume you have already set up the necessary cloud provider credentials and configured `kubectl` to communicate with your cluster.

In this example, we'll use the Pulumi Kubernetes provider to deploy the Helm chart `nginx` from the `stable` repository. This Helm chart installs the `nginx` ingress controller. The ingress controller can serve as a reverse proxy and load balancer for your Kubernetes services.

Here's how you can do it:

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

// Create a Kubernetes provider instance using the current context of `kubectl`.
const provider = new k8s.Provider("k8s-provider", {
  // If you are targeting a specific kubeconfig context or cluster, specify that here
  // For example:
  // kubeconfig: "your-kubeconfig-file",
  // context: "your-kubeconfig-context",
});

// Deploy the NGINX ingress controller using the Helm chart.
const nginxIngressController = new k8s.helm.v3.Chart("nginx-ingress", {
  chart: "nginx-ingress",
  // Change to the version you want to use
  version: "1.41.3",
  // Optionally, specify the repository URL if it's not a chart from the 'stable' repository
  // repositoryOpts: {
  //   repo: "https://charts.helm.sh/stable"
  // },
  // You could override default values here similar to `helm install --set key=value`
  values: {
    // Some example overrides
    // controller: {
    //   metrics: {
    //     enabled: true,
    //   },
    // },
  },
}, { provider });

// Export the public IP or Hostname of the ingress controller if needed
export const ingressEndpoint = nginxIngressController.getResourceProperty(
  "v1/Service",
  "nginx-ingress-controller",
  "status"
).apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);
```

This program does the following:
- Imports the required Pulumi Kubernetes module.
- Creates a Kubernetes provider that uses the current context from your `kubectl` configuration. If you have multiple contexts or a specific kubeconfig file for your cluster, you should specify it in the provider configuration.
- Deploys the `nginx-ingress` Helm chart to provision an ingress controller in your cluster. This is specified with the `chart` and `version` properties. If your chart is located in a custom Helm repository, you must provide the `repositoryOpts` with the `repo` URL.
- Optionally override default chart values under the `values` object. This step is equivalent to using the `--set` flag with the `helm` CLI.
- Exports the resultant ingress endpoint, either an IP or a hostname, to be used to access services through the ingress controller.

Before running this Pulumi program, make sure your Pulumi CLI is installed, and you are logged in to a Pulumi backend to store your state (e.g., the Pulumi Service, a cloud bucket, or locally). Also, verify that your Kubernetes cluster is running and you are authenticated through `kubectl`.

Remember, this Pulumi script is scoped to deploying a specific Helm chart on an existing Kubernetes cluster. If you want to create a Kubernetes cluster with Pulumi or configure other cloud resources, you can also do that with different Pulumi components and providers.