Deploy the litmus-core helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy the litmus-core Helm chart on a Kubernetes cluster using Pulumi, we will use the `kubernetes.helm.v3.Chart` resource. This Pulumi resource allows us to deploy Helm charts in a Kubernetes cluster by specifying the chart's repository, name, and configuration options that you might want to override.

Before we write the TypeScript program, here are the steps that the program will follow:
1. We will reference the `kubernetes` package, which provides us with the necessary resources for interacting with Kubernetes.
2. We will create an instance of `Chart` within the desired Kubernetes namespace (defaulted to "default" if not specified).
3. We will specify the `litmus-core` chart and its repository URL.

Below is a TypeScript program that demonstrates how to deploy `litmus-core`:

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

// Create a Helm Chart resource for the litmus-core chart from the litmus Helm repository.
// Set the release name to "litmus-core" and deploy it into the "default" namespace.
const litmusChart = new kubernetes.helm.v3.Chart("litmus-core", {
    // The repository where the helm chart is located.
    repo: "litmuschaos",
    // The name of the chart to deploy.
    chart: "litmus-core",
    // Chart version to deploy. Omit to install the latest version.
    // version: "x.y.z",
    // You can specify a namespace or leave it as default.
    namespace: "default",
    // Values to provide to the chart.
    // These settings are chart-specific; refer to the chart's values.yaml file.
    // values: { ... },
}, { provider: /* the k8s provider if not using the default */ });

// Export the Helm chart's name and status after deployment.
export const litmusCoreChartName = litmusChart.metadata.name;
export const litmusCoreChartStatus = litmusChart.status;
```

In this program:

- We import the `@pulumi/kubernetes` package, which contains the necessary components to work with Kubernetes through Pulumi.
- We declare a `litmusChart` constant, which creates a new Helm chart resource using the `Chart` class from `kubernetes.helm.v3`.
- We specify the necessary parameters such as the repo (`litmuschaos`), chart name (`litmus-core`), and the namespace to deploy the chart in. If you have a different namespace, you can specify it in place of `default`.
- Optionally, you could specify the `version` property to deploy a specific version of the chart. If not provided, the latest version from the repository will be deployed.
- If you need to customize the deployment with specific configurations, you would provide a `values` object containing your overrides. These overrides correspond to the configurable parameters in the chart’s `values.yaml` file.
- Optionally, if you're not using the default Kubernetes provider (i.e., the default kubeconfig context), you would pass a `provider` option to specify an alternative provider configuration.
- Finally, we export the name and status of the deployed chart, which you can view after the deployment.

To execute this Pulumi program:

1. Install Pulumi and set up your Pulumi account if you haven’t already.
2. Install Node.js and npm to run the Pulumi program in TypeScript.
3. Create a new directory and initialize a new Pulumi project.
4. Replace the contents of `index.ts` with the above program.
5. Run `npm install @pulumi/kubernetes` to install the necessary Kubernetes plugin for Pulumi.
6. Execute `pulumi up` to preview and deploy the resources.

The program will interact with your Kubernetes cluster and deploy the litmus-core Helm chart as specified. You'll see the outputs on the terminal once the deployment is finished.