Deploy the stream helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Kubernetes cluster with Pulumi, you'll use the `Chart` resource from the `@pulumi/kubernetes` package. This resource allows you to deploy a Helm chart from a repository or a local path. Deploying a chart involves specifying the repository URL or path to the chart, the name of the chart, and optionally, any configuration values (overrides for default settings) your deployment requires.

To use the `Chart` resource, you'll first need to ensure you have the Pulumi CLI and `@pulumi/kubernetes` SDK installed. You should also have access configured to a Kubernetes cluster where you will deploy this Helm chart. Once you are set up, you can proceed to write a Pulumi program in TypeScript to deploy the "stream" Helm chart.

Here is a Pulumi TypeScript program that deploys the "stream" Helm chart:

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

// Create an instance of the Chart resource to deploy the 'stream' helm chart on Kubernetes.
const streamChart = new k8s.helm.v3.Chart("stream-chart", {
    // Specify the repository where your chart is located.
    // For this example, we're using a fictional repository URL as an example.
    // Replace 'https://charts.example.com/' with the actual repository URL for the 'stream' chart.
    repo: "my-repo",
    
    // The name of the chart you wish to deploy.
    // In our case, it's 'stream'.
    chart: "stream",
    
    // Specify the version of the chart to deploy.
    version: "1.0.0", // Replace this with the actual chart version you wish to deploy.
    
    // Provide any custom values to override the default chart values.
    // This is equivalent to passing a custom `values.yaml` file with `helm install`.
    values: {
        // Example of setting a custom value. Replace or extend this with actual chart values.
        service: {
            type: "ClusterIP",
        },
    },
    
    // Define the namespace to deploy the Helm chart into, or leave it undefined to use the default namespace.
    // If the namespace does not exist, it will be created.
    namespace: "stream-namespace",
});

// Export the base URL for the stream service, if the service type is LoadBalancer and exposes an external IP.
export const streamUrl = streamChart.getResourceProperty("v1/Service", "stream-chart-stream", "status").apply(status => {
    const ingresses = status.loadBalancer?.ingress ?? [];
    return ingresses.length > 0 ? `http://${ingresses[0].ip}/` : undefined;
});
```

Let's break down what the above code does:

1. It imports the Pulumi Kubernetes SDK.
2. It creates a `Chart` resource representing the Helm chart to be deployed.
3. We specify the Helm repository and chart name. Make sure to replace `"my-repo"` and the version with the actual repository and version information for your "stream" chart.
4. We set custom values which override the defaults provided by the chart itself. In the example, we set the service type to `"ClusterIP"`. You should replace or extend this section with the values specific to the "stream" chart.
5. The `namespace` property specifies the Kubernetes namespace where the chart should be deployed. If not specified, the default namespace will be used. Here, it uses `stream-namespace`.
6. Lastly, we export the URL of the "stream" service so that you can easily access the running application. The `.apply` method is used here to extract the URL only if it is exposed externally.

To run this Pulumi program, you'll need to execute it with Pulumi CLI commands: `pulumi up` to preview and deploy the changes, and `pulumi destroy` when you want to remove the resources. If you need more specific instructions or have further questions, feel free to ask.