Deploy the simple-db-app-chart-with-dependency helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Kubernetes using Pulumi, you will need to have a Kubernetes cluster running and have `kubectl` configured to connect to your cluster. In this example, we will use the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider to deploy a Helm chart named `simple-db-app-chart-with-dependency`.

The `kubernetes.helm.v3.Chart` resource allows you to deploy a Helm chart from a repository or a local path. It also supports passing custom values to the Helm chart, setting the namespace for the deployment, and managing the chart's release lifecycle.

Here is a Pulumi program written in TypeScript that demonstrates how to deploy your Helm chart:

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

// Name of the Helm chart
const chartName = "simple-db-app-chart-with-dependency";
// In this example, we're assuming the chart is available in a repository.
// Replace with the appropriate repository URL where the chart is hosted.
const repoUrl = "https://your-helm-chart-repository.com/charts";

// Define the Helm release using the `Chart` resource.
const helmRelease = new k8s.helm.v3.Chart(chartName, {
    // Specify the Helm repository where your chart can be found.
    repo: "myrepo",
    chart: chartName,
    // If the chart version is not specified, the latest version is used.
    version: "1.0.0",
    // Define any values here that you need to override the chart's defaults.
    // It might be empty if no overrides are needed, or you could add values like below.
    values: {
        // Example of overriding a service's type to use NodePort instead of ClusterIP.
        service: {
            type: "NodePort",
        },
        // Add other overrides here as needed.
    },
    // Optional: specify the namespace to deploy into.
    namespace: "default",
}, {
    // Specify that if the program is destoyed, do not destroy the Helm release.
    protect: true,
});

// Export the base URL of the service once the chart is deployed.
// This assumes that your chart creates a service. Adjust the property access as necessary.
export const serviceUrl = helmRelease.getResourceProperty("v1/Service", "my-app-service", "status")
    .apply(status => `http://${status.loadBalancer.ingress[0].ip}:80`);
```

Here's what each part of the program does:

- First, we import the necessary Pulumi Kubernetes library.
- We define `chartName` and `repoUrl` to refer to the Helm chart's name and repository URL.
- We create a new Helm chart release by instantiating the `k8s.helm.v3.Chart` resource with:
  - `repo`: The short name of your Helm repository.
  - `chart`: The name of your chart in the repository.
  - `version`: (optional) The specific chart version you want to deploy. If not provided, the latest version is used.
  - `values`: (optional) Any custom values you want to override in your Helm chart.
  - `namespace`: (optional) The Kubernetes namespace in which to deploy the Helm chart. If not provided, the default namespace is used.
  - `protect`: (optional) If set to `true`, the Helm release will not be deleted even if the Pulumi program is destroyed. Useful for persisting resources outside of the lifecycle of the Pulumi program.

After deploying this Pulumi program with `pulumi up`, your Helm chart would be deployed to the cluster, and you would see outputs printed to your console after the deployment completes, including `serviceUrl` if applicable.

Remember to replace `your-helm-chart-repository.com/charts` in `repoUrl` with the actual URL of your Helm chart repository and make sure that the Helm repository has been added to your Helm client configuration. If you're deploying a chart from a local path, modify the resource instantiation accordingly.

Make sure that you have Pulumi and your Kubernetes cluster configured correctly before running the program. If you don't have a cluster, you can create one using Pulumi's EKS, AKS, or GKE support, or use any existing one.

With the `protect` option set, you can ensure that the Helm release will not be destroyed if you destroy the Pulumi stack, which is particularly useful in production environments where accidental deletion should be prevented.

The `serviceUrl` export assumes that the Helm chart you're deploying creates a Kubernetes `Service` that exposes your application, and that service is of type `LoadBalancer`. Adjust your `getResourceProperty` call accordingly if your service is named differently or to suit different service types like `NodePort` or `ClusterIP`.