Deploy the metrics-generator helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Kubernetes cluster using Pulumi is a straightforward process that involves writing a program that defines the desired state of the resources. In this example, we will deploy a Helm chart named `metrics-generator`. Assuming you have a Kubernetes cluster already provisioned and `kubeconfig` is set up correctly, we'll use the `kubernetes` package in Pulumi to deploy the Helm chart.

Pulumi uses `yaml` files to describe the desired state of your Kubernetes resources in a declarative manner. The Pulumi program below is an equivalent representation using TypeScript, which allows for more dynamic and programmatic definitions, like loops, conditionals, and variables.

In the code below, we import the required `@pulumi/kubernetes` package, which contains helpers for deploying resources to Kubernetes using Pulumi. Then, we create an instance of a `Chart` resource from `@pulumi/kubernetes/helm/v3`, which will install the `metrics-generator` Helm chart into the Kubernetes cluster. The `Chart` resource takes several options, such as the chart name, version, and any custom values you may need to provide to configure the chart.

Here's the program that deploys the `metrics-generator` Helm chart to the default namespace:

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

// Instantiate the metrics-generator Helm chart
const metricsGeneratorChart = new k8s.helm.v3.Chart("metrics-generator", {
    // Replace with the chart name you are deploying
    chart: "metrics-generator",

// If the chart is from a custom Helm repo, specify it here
    // For example, to use the Bitnami repo:
    // repo: "https://charts.bitnami.com/bitnami",

// Optionally, you can specify the version of the chart you want to deploy
    // For example, to use version 1.0.0 of the metrics-generator chart:
    // version: "1.0.0",

// If your chart requires custom values, provide them as a JSON object
    // For example, if you need to set a replicaCount value:
    // values: {
    //     replicaCount: 2,
    // },

// The namespace where the chart will be deployed
    namespace: "default",  
});

// Export the resulting resource's name
export const chartName = metricsGeneratorChart.metadata.name;
```

This program defines a single Pulumi resource, the `metrics-generator` Helm Chart, which will be deployed to the default namespace.

Here's what each part of the code does:

- `import * as k8s from "@pulumi/kubernetes";`: This imports the Pulumi Kubernetes package, allowing us to define Kubernetes resources.
- `const metricsGeneratorChart = new k8s.helm.v3.Chart("metrics-generator", {...});`: This line creates a new Helm chart resource named `metrics-generator` using the given properties object.
- `chart: "metrics-generator"`: Specifies the name of the chart to deploy. Ensure that the Helm chart you want to install is named `metrics-generator` or replace this with the correct chart name available in your Helm chart repository.
- `repo: "https://charts.bitnami.com/bitnami"`: (Optional) The URL of the custom Helm repository where your chart is hosted. Uncomment and edit this line if the `metrics-generator` chart is not in the default Helm repository.
- `version: "1.0.0"`: (Optional) If there's a specific version of the Helm chart that you need, specify it here. Otherwise, the latest version will be installed. Replace the version number with the one you need.
- `values: { ... }`: (Optional) If the Helm chart you're deploying requires any custom values (e.g., configuring the number of replicas), provide them here in JSON format.
- `namespace: "default"`: This specifies the Kubernetes namespace where the chart will be deployed. If you want to deploy the chart to a different namespace, replace `"default"` with the desired namespace name.
- `export const chartName = metricsGeneratorChart.metadata.name;`: This line exports the name of the deployed Helm chart as a stack output, which can be useful for querying and managing the chart post-deployment using Pulumi CLI commands.

Remember, this is a basic example. Helm charts can have a wide variety of settings and configurable options. You'll want to consult the documentation for the specific chart you're deploying to understand what settings you may need to specify.

To run this Pulumi program:
1. Install Pulumi and set up your Kubernetes cluster configuration.
2. Create a new directory and initialize a Pulumi project in your favorite language (TypeScript in this example).
3. Install the needed Pulumi Kubernetes SDK by running `npm install @pulumi/kubernetes`.
4. Place the program code in your `index.ts` file.
5. Run `pulumi up` to execute the code and deploy your Helm chart to the cluster.

The `pulumi up` command will show you a preview of the resources that will be created and prompt you to confirm the deployment. After confirmation, Pulumi will proceed to apply the changes and deploy the Helm chart to your Kubernetes cluster.