Deploy the stage helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Kubernetes cluster using Pulumi, you would first need to have a Kubernetes cluster running and accessible. Assuming you have that set up and your `kubectl` is configured correctly to communicate with your cluster, the next step would be to use Pulumi's Kubernetes provider to deploy the Helm chart.

Pulumi's `kubernetes.helm.v3.Chart` resource enables you to deploy Helm charts into a Kubernetes cluster. Helm charts are packages of pre-configured Kubernetes resources, and they are a great way to manage and deploy applications on Kubernetes.

When creating a `Chart` resource in Pulumi, you'll specify the chart's name and settings, which could include the namespace, version, values to override default configuration, and the repository if it's a public chart that's not already locally cached.

Below is a TypeScript Pulumi program that demonstrates how to deploy a hypothetical "stage" Helm chart onto your Kubernetes cluster.

### Pulumi Program to Deploy a Helm Chart on Kubernetes

Here's a step-by-step guide, followed by the complete program:

1. **Set up**: Import the required Pulumi and Kubernetes packages.
2. **Chart Deployment**: Create a new Helm chart resource. For `chart`, provide the name of the chart you want to deploy (I used `"stage"` as an example). If your chart is from a custom repository, specify `repo`. You can also include `version` to deploy a specific chart version and `values` to override default configurations.
3. **Access The Application**: After deployment, you typically want to access your application. You can export the necessary details, such as service endpoints.

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

// Create an instance of the Helm Chart "stage". This assumes that the Helm chart is available in a repository.
const stageChart = new k8s.helm.v3.Chart("stage", {
    chart: "stage",
    // Specify the namespace where the chart should be installed.
    namespace: "default",
    // If the Helm chart comes from a custom repository, you'd also need to specify the `repo` option.
    // e.g., repo: "https://charts.example.com/",
    // Specify chart version and configuration values here.
    version: "1.2.3",
    values: {
        // key-value pairs go here to override default chart values
        // e.g., service: { type: "LoadBalancer" },
    },
    // This option skips the await logic after the Helm chart is deployed, which could be useful
    // if the chart includes CRDs or resources that Pulumi does not yet support awaiting on.
    skipAwait: false,
});

// To interact with your application, you would typically want the service endpoint.
// For demonstration, let's assume your chart creates a K8s service for the application.
// We'll fetch the service object and export its cluster IP.
const stageService = stageChart.getResource("v1/Service", "stage");

export const serviceEndpoint = stageService.status.apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);

```

### Explanation

- `@pulumi/kubernetes`: This is the Pulumi Kubernetes SDK, which allows you to declare Kubernetes resources using code.
- `k8s.helm.v3.Chart`: This is the Pulumi resource type for deploying a Helm chart.
- `namespace`: Kubernetes namespaces help different projects, teams, or customers to share a Kubernetes cluster by providing scope for names.
- `chart`: The name of the Helm chart you want to install.
- `version`: The specific version of the Helm chart you want to deploy.
- `values`: Any overrides to the default values that come with the Helm chart.
- `skipAwait`: This controls whether to wait until all resources are in a ready state before marking the deployment as complete.
- `getResource`: A method to fetch a Kubernetes resource created by the Helm chart after the chart is deployed.
- `apply`: A Pulumi function to run a callback function on the output of a Pulumi resource.

Remember to install `@pulumi/kubernetes` package before running the Pulumi program:

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

Please replace `"stage"` with the actual name of your Helm chart and provide the correct chart repository, version, and value overrides for your specific scenario.

After writing this Pulumi program to a `.ts` file (e.g., `index.ts`), you can deploy it with the Pulumi CLI:

```bash
pulumi up
```

This command will prompt you to review the changes and confirm them before proceeding with the deployment.

Keep in mind that you'll need to have Pulumi set up and logged in to an account, which you can do via the Pulumi CLI, and have access to a Kubernetes cluster for the code to run successfully.