Deploy the stateless helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Kubernetes using Pulumi involves creating a Pulumi program that defines the Kubernetes resources necessary to deploy and manage the Helm chart of your application. Helm is a package manager for Kubernetes, which uses a collection of files called a "chart" to define a set of Kubernetes resources as a single unit that can be deployed.

A stateless application in Kubernetes is one that does not retain any data after its container is restarted. This means the application does not rely on the persistent storage of any kind. This is typically the case for front-end applications or APIs where state is either not important or is delegated to more suitable systems like databases.

Below, I'm going to walk you through a Pulumi TypeScript program that deploys a stateless Helm chart onto a Kubernetes cluster:

1. **Setup**: Ensure you have installed Pulumi CLI, and you are authenticated with Kubernetes (for instance, having a valid `~/.kube/config` file for your Kubernetes cluster).

2. **Project**: Create a new Pulumi project using `pulumi new` command and choose the `kubernetes-typescript` template.

3. **Program**: Write a TypeScript program as shown below. The program leverages Pulumi's Kubernetes package to interact with your Kubernetes environment.

4. **Helm Chart**: The `Chart` resource from Pulumi's Kubernetes package is used to install a chart from a Helm repository.

Let's start by detailing out the TypeScript program:

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

// Define the namespace where the Helm chart will be deployed.
const namespace = new k8s.core.v1.Namespace("app-namespace", {
    metadata: {
        name: "stateless-app",
    },
});

// Deploy the stateless application using a Helm chart.
const helmChart = new k8s.helm.v3.Chart("stateless-app", {
    namespace: namespace.metadata.name,
    chart: "my-stateless-app", // Replace with the name of your chart
    version: "1.2.3", // Replace with the chart version you want to deploy
    fetchOpts: {
        repo: "http://myhelmrepo.com/charts", // Replace with the URL of your Helm repository
    },
    // Values to pass to the Helm chart.
    // These would be specific to the Chart you are deploying.
    values: {
        service: {
            type: "ClusterIP",
        },
        // More values can be added based on the Chart's requirements.
    },
});

// Export the name of the namespace
export const namespaceName = namespace.metadata.name;
```

This program accomplishes the following:
- It imports the necessary `@pulumi/kubernetes` package to deploy resources to Kubernetes using Pulumi.
- It creates a new `Namespace` resource for our stateless application to keep it separate from other resources in the cluster.
- It uses the `Chart` resource to specify which Helm chart to deploy to Kubernetes, pointing to the chart name, version, and the repository where the chart is hosted. You would replace `"my-stateless-app"`, `1.2.3`, and `"http://myhelmrepo.com/charts"` with the actual details of your Helm chart.
- The `values` property allows you to customize your Helm chart deployment by providing the required configuration for your chart.
- Finally, it exports the namespace's name, which can be useful if you want to reference this namespace in other parts of your program or in another Pulumi stack.

After writing this program, deploying your Helm chart is as simple as running `pulumi up` command in the project directory. Pulumi will execute the plan described in your TypeScript code, and you will see the resources being created on your Kubernetes cluster in the terminal output.

Remember that you will need access to the Kubernetes cluster that you intend to deploy the chart on and the cluster must be compatible with the Helm chart specification that you are using. Also, the values you fill in the `values` object must match the expectations of the Helm chart you are deploying.