Deploy the eval-ob-pattern-2 helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Kubernetes using Pulumi, you need to perform these steps:

1. **Set up the Pulumi Kubernetes Provider**: This allows Pulumi to interact with your Kubernetes cluster. For this, you must have `kubeconfig` set up correctly on your machine or passed explicitly within your Pulumi code. Pulumi uses this configuration to deploy the Helm chart to the correct cluster.

2. **Use the `Chart` resource from Pulumi's Kubernetes provider**: The Helm `Chart` resource is a high-level abstraction that deploys a Helm chart into your Kubernetes cluster. You need to specify the chart name, version, and any custom values that you would like to override in the chart's default configuration.

3. **Export any necessary resources**: After deployment, you might want to export resource properties like the cluster IP or load balancer URL so that you can easily access them.

Below is a Pulumi TypeScript program that demonstrates how to deploy a Helm chart named `eval-ob-pattern-2` on a Kubernetes cluster:

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

// Deploying a Helm Chart named 'eval-ob-pattern-2' into a Kubernetes cluster.
// This example assumes that you have a chart available locally or in a remote Helm repository.
const evalChart = new k8s.helm.v3.Chart("eval-ob-pattern-2", {
    // Specify the chart repository URL, if the chart is not local.
    // If the chart is stored locally, provide the local path to the chart directory.
    repo: "your-chart-repo",
    chart: "eval-ob-pattern-2",
    // Specify the version of the chart.
    version: "1.0.0",
    // Values to override the chart's default configurations.
    // If you have values in a separate file (e.g., values.yaml), you can pass the file path.
    values: {
        service: {
            type: "LoadBalancer"
        },
        // Add more custom values as needed for your chart configuration.
    },
    // If needed, you can also set a namespace. Otherwise, default namespace will be used.
    // namespace: "default",
    // Add additional configuration options if necessary.
});

// Export the service's LoadBalancer IP or hostname to access the service externally.
// Depending on the service type and your Kubernetes provider,
// this IP/hostname can be used to interact with the deployed service.
export const serviceIP = evalChart.getResourceProperty("v1/Service", "eval-ob-pattern-2-service", "status").apply(status => status.loadBalancer.ingress[0].ip);
export const serviceHostname = evalChart.getResourceProperty("v1/Service", "eval-ob-pattern-2-service", "status").apply(status => status.loadBalancer.ingress[0].hostname);

// To run this program, execute `pulumi up`. This will prompt Pulumi to perform an update, during which it will
// carry out the deployment of the chart as per the specifications above.
```

In the above program:

- We import the Pulumi Kubernetes package.
- We create a new Helm chart deployment `evalChart` using the `Chart` resource.
- We specify the chart repository if it's hosted remotely via `repo`. If the chart is local, you'll replace this with the `path` property and provide the filesystem path to the local chart.
- We set custom values, which are dependent on the specifics of the `eval-ob-pattern-2` Helm chart. Custom values can be anything exposed for customization by the Helm chart, such as replica counts, image names, or service types. Here, as an example, we are setting the service type to `LoadBalancer`.
- We export the IP and hostname, which allows us to access the LoadBalancer service created by the Helm chart once deployed.

Make sure to replace `"your-chart-repo"`, `"1.0.0"`, and the custom `values` with the actual information relevant to the `eval-ob-pattern-2` Helm chart you wish to deploy.

Before running the [`pulumi up`](https://www.pulumi.com/docs/reference/cli/pulumi_up/) command to apply this Pulumi program, ensure that you have the correct Kubernetes context selected so that Pulumi deploys the chart to your intended cluster. Pulumi will use the active context from your `kubeconfig`. You should also have Pulumi installed and set up for TypeScript.

Feel free to modify the `values` field to customize the Helm chart according to your needs. Using the `getResourceProperty` method, we try to fetch the LoadBalancer ingress details, which might be useful if your Helm chart is expected to create a LoadBalancer type service for external access. Note that these outputs will only be available if the associated resources and properties exist after the chart is deployed.