Deploy the ingresses helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy an ingresses Helm chart on a Kubernetes cluster with Pulumi, you'll use the `kubernetes.helm.v3.Chart` resource. This resource is responsible for deploying a chart from Helm directly into your Kubernetes cluster managed by Pulumi.

Helm charts are packages of pre-configured Kubernetes resources. When you deploy a chart, Helm combines the chart with configuration information from the `values.yaml` file and other sources (such as values passed at the command line) to generate the Kubernetes resource definitions (such as Deployments, Services, etc.). The `kubernetes.helm.v3.Chart` resource allows you to specify the name of the chart and its settings, which might include the version of the chart, values to override default configuration settings, and the namespace where it should be deployed.

Here's a TypeScript program that accomplishes the task:

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

// Assume your Kubernetes cluster is already configured and accessible via Pulumi.
// If not, you would have set up the provider here to connect to your cluster.

// Deploying the 'ingresses' Helm chart to the 'default' namespace in Kubernetes.
const ingressChart = new kubernetes.helm.v3.Chart("ingress-chart", {
    // Replace with the specific chart name you want to deploy.
    chart: "ingress",
    version: "1.2.3", // Specify the chart version you want to deploy.
    // If the chart is from a custom Helm repo, you have to specify `repo` field as well.
    values: {
        // Provide configuration values for the chart here.
        // These values would typically be placed in a custom values.yaml file for the Helm chart.
        // For example: 
        // service: { type: "ClusterIP" },
    },
    // If the chart requires custom fetch options, you can specify them here.
    // for example:
    // fetchOpts: { repo: "http://charts.example.com/" },
});

// Export the ingress's public IP to access your service.
export const ingressIp = ingressChart.getResourceProperty("v1/Service", "ingress-chart", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

In the above program:

- We first import the `@pulumi/kubernetes` package, which provides the APIs to interact with Kubernetes using Pulumi.
- We then create a new Helm chart resource using `new kubernetes.helm.v3.Chart()`.
- Inside the `Chart` constructor:
  - `"ingress-chart"` is just a name we give to the Pulumi resource. It can be anything and serves as a reference within your Pulumi program.
  - `chart: "ingress"` specifies the name of the Helm chart you want to deploy. You would replace `"ingress"` with the actual chart name.
  - `version: "1.2.3"` denotes the specific version of the Helm chart you want to use. It is good practice to specify the chart version to ensure that your deployments are repeatable.
  - `values` is an Object that contains configuration options for the Helm chart.
  - `fetchOpts` is an optional field you could specify if you're using a custom Helm repository; if the chart is in the public Helm repository, this isn't necessary.
- Finally, we export a resource property using `export`, which allows us to access the deployed resources' properties. In this case, we're retrieving the IP address assigned to the load balancer service of the ingress, assuming the service type is `LoadBalancer`. If your ingress controller does not use a `LoadBalancer` service or if you are interested in a different piece of information, you will need to adjust this accordingly.

Make sure to replace the placeholders with the actual values that correspond to your ingress Helm chart deployment.

Ensure to install the necessary Pulumi packages by running:

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

After writing this code in a file (e.g., `index.ts`), you can deploy it using the Pulumi CLI:

```bash
pulumi up
```

This will prompt Pulumi to perform an update, showing you the planned changes before it makes them. If you confirm, Pulumi will proceed with deploying the specified Helm chart to your Kubernetes cluster.