Deploy the robot-template helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Kubernetes using Pulumi, you'll use the `Chart` resource from the Pulumi Kubernetes provider. This resource allows you to deploy a Helm chart from various sources such as a Helm repo, a local path, or even directly from the chart's tarball.

Below is a TypeScript program that demonstrates how to deploy the `robot-template` Helm chart. It assumes you have a Kubernetes cluster already running and that `kubectl` is configured to communicate with it. The program uses Pulumi's Kubernetes provider to deploy the chart.

First, you'll need to import the necessary Pulumi and Kubernetes packages. Then, create an instance of the `Chart` resource, specifying the name of the chart, the repository where the chart can be found, and any custom values you want to use when deploying the chart.

Here's how you can do it:

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

const namespace = "default"; // Use your own namespace if different

// Deploy the robot-template Helm chart into the Kubernetes cluster
const robotTemplateChart = new k8s.helm.v3.Chart("robot-template-chart", {
    chart: "robot-template",
    version: "1.0.0", // specify the version of the chart
    namespace: namespace,
    // If the chart is in a Helm repository, specify the repo URL
    // Note: Uncomment and fill `repo` with the actual repository if it's not in the default Helm repo.
    // repo: "<repository-url>",

// Specify any custom values for the chart.
    // Note: Customize the values or remove the `values` field if there are no custom values needed.
    values: {
        // For example, if the chart accepts a custom image and tag
        // image: {
        //     repository: "your-repo/your-image",
        //     tag: "latest"
        // },

// You might also specify other custom values depending on the chart's `values.yaml`
    },
}, {
    // Pulumi options to specify dependencies or providers if necessary
    // dependencies: [/* ... */],
});

export const chartName = robotTemplateChart.metadata.name;
```

In this program:
- `@pulumi/kubernetes` is being imported to use Pulumi's Kubernetes provider.
- A `Chart` resource called `robotTemplateChart` is being created.
- We specify the `chart`, `version`, and `namespace` where the chart should be deployed. Ensure to replace `1.0.0` with the appropriate chart version.
- Under `values`, you would list any overrides to the default [values.yaml](https://helm.sh/docs/chart_template_guide/values_files/) provided by the chart. These could be configurations like image registry, replica count, or any other configurable parameters that the chart provides.
- Optionally, if the Helm chart is hosted in a custom repository, you would provide the URL in the `repo` field. Uncomment and set the `repo` to the URL of the Helm repository where `robot-template` is hosted.
- The `export` statement exposes the chart name as an output of the Pulumi stack, which can be useful for querying or performing operations post-deployment.

To apply the above Pulumi code, run `pulumi up` from your command line after creating a new Pulumi project and setting up the `index.ts` with the above content. Make sure that Pulumi is configured correctly to interact with your Kubernetes cluster by setting appropriate credentials.

Make sure that you have installed the required packages by running:

```bash
npm install @pulumi/kubernetes
```

or if you are using Yarn:

```bash
yarn add @pulumi/kubernetes
```

Pulumi will now handle the process of setting up the chart similar to how `helm install` does, but giving you the benefits of infrastructure as code practices.