Deploy the enterprise helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Kubernetes cluster using Pulumi, you'll need to use the `@pulumi/kubernetes` package which provides the necessary resources to interact with Kubernetes including deploying Helm charts. Pulumi uses the desired state configuration model, where you declare the desired state of your infrastructure, and Pulumi makes the necessary changes to achieve that state.

The `kubernetes.helm.v3.Chart` class from Pulumi's Kubernetes provider is a resource that represents a Helm chart in a declarative way. When you instantiate an instance of this resource, Pulumi will ensure that the Helm chart is applied to your Kubernetes cluster with the specified configuration.

Here is a TypeScript Pulumi program that demonstrates how to deploy an enterprise Helm chart on a Kubernetes cluster.

First, ensure you have [installed Pulumi and configured it for use with your Kubernetes cluster](https://www.pulumi.com/docs/get-started/kubernetes/).

Next, initialize a new Pulumi project using `pulumi new` if you haven't already done so. You can select the Kubernetes template to start with a preconfigured project.

Now you can create a file named `index.ts` and use the following program:

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

// The name of the Helm chart you want to deploy. For example, "my-enterprise-app".
const chartName = "my-enterprise-app";

// Optionally, you can specify the version of the Helm chart.
const chartVersion = "1.2.3"; // Replace with the actual chart version you need.

// Optionally, if the Helm chart is hosted on a custom Helm repository, specify the repository URL.
const repo = "https://example.com/helm-charts"; // Replace with the actual Helm repo URL.

// To deploy a specific namespace, specify it here. If not, Helm will deploy to the default namespace.
const namespace = "prod"; // Replace with the namespace you wish to deploy to.

const enterpriseChart = new k8s.helm.v3.Chart(chartName, {
    chart: chartName,
    version: chartVersion,
    fetchOpts: {
        repo: repo
    },
    namespace: namespace,
    // Values in here are passed to the Helm chart's values.yaml file.
    // Replace these with the necessary configuration for the enterprise chart.
    values: {
        key1: "value1",
        key2: "value2",
        // Add more configuration values as necessary.
    },
}, { provider: k8sProvider }); // Specify your Kubernetes provider if not using the default one.

// Export the base URL for the service, which can be used to access the application.
export const url = enterpriseChart.getResourceProperty("v1/Service", "my-service", "status").apply(s => `http://${s.loadBalancer.ingress[0].ip}`);
```

In this program:
- Replace `my-enterprise-app` with the name of your Helm chart.
- Replace `1.2.3` with the version of the Helm chart you wish to deploy.
- Replace `https://example.com/helm-charts` with the URL of your Helm repository if your chart is not in the official Helm repository.
- Set `namespace` to the Kubernetes namespace you wish to deploy your Helm chart; if you omit it, Helm defaults to the `default` namespace.
- Under the `values` key, replace `key1`, `key2`, etc., with the actual values required for your Helm chart.
- The `export` statement at the end allows you to retrieve the URL to access the deployed service if your Helm chart exposes any. Note this snippet assumes that the chart exposes a service with an external LoadBalancer; if your setup is different, you'll need to adjust the code accordingly.
- Replace `my-service` with the actual name of the service defined in your Helm chart.
- If you're not using the default Kubernetes provider, replace `k8sProvider` with the instance of your configured provider.

After setting up your `index.ts` file, run `pulumi up` from your command line to preview and deploy the changes. Pulumi will print out the expected state changes and prompt you to confirm before applying those changes to your Kubernetes cluster.
  
After the deployment succeeds, you should be able to access your chart's services using the URL printed by the `export` statement, assuming your service is of type `LoadBalancer`.