Deploy the ingress-helm-chart helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart for an ingress controller on a Kubernetes cluster using Pulumi, you will need to use the `kubernetes.helm.v3.Chart` resource. This resource is a representation of a Helm chart in the Pulumi programming model, and you can use it to deploy any Helm chart available from a chart repository or from a local directory. In this case, the `ingress-helm-chart` might refer to a generic ingress-related Helm chart, such as `nginx-ingress` or another ingress controller of your choice.

Here is a step-by-step breakdown of how to use the `kubernetes.helm.v3.Chart` resource in TypeScript:

1. Import the necessary Pulumi Kubernetes package.
2. Create a new instance of `kubernetes.helm.v3.Chart`.
3. Set the necessary parameters like `chart` (the name of the chart), `version` (specific chart version, which is optional), `repositoryOpts` (if you are installing from a remote Helm repository), and `values` (an object to override default chart values, also optional).

Please note, to execute the following program, you must have Pulumi installed and configured with access to a Kubernetes cluster. Below is a TypeScript program that demonstrates how to deploy an ingress controller using a Helm chart. Adjust the `chart` and `version` properties to match the specific ingress Helm chart you wish to deploy. If it's a custom Helm chart you created or downloaded, you would set the `path` property to the directory containing your chart files instead.

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

// Create an instance of the helm.v3.Chart resource to deploy the ingress controller.
// Replace 'nginx-ingress' with the actual name of the Helm chart you intend to deploy.
// If you have your ingress-helm-chart locally, use the `path` parameter instead of `chart` and `repo`.
const ingressHelmChart = new kubernetes.helm.v3.Chart("ingress-controller", {
    chart: "nginx-ingress",
    version: "3.34.0", // specify the version of the chart to deploy
    fetchOpts: {
        repo: "https://kubernetes.github.io/ingress-nginx", // URL of the Helm repository
    },
    // Values to override in the Helm Chart.
    // This is equivalent to the `--set` flag in the Helm CLI.
    values: {
        controller: {
            publishService: {
                enabled: true, // Determine if the controller Service should be exposed
            },
            service: {
                type: "LoadBalancer", // Use a LoadBalancer to expose the ingress controller
            },
        },
    },
}, { provider: /* you need to pass the provider if you have multiple clusters */ });

// Export the public IP address of the ingress if using a LoadBalancer service.
export const ingressIp = ingressHelmChart.getResourceProperty("v1/Service", "ingress-controller-nginx-ingress-controller", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

In the above program:

- We import the `@pulumi/kubernetes` package to interact with Kubernetes resources using Pulumi.
- We instantiate a new `kubernetes.helm.v3.Chart` resource, which represents the Helm chart we want to deploy.
- We specify the name "nginx-ingress" as an example name for the Helm chart, along with the version and the repository URL where the chart can be found. If you're deploying a different ingress controller or using a specific version, you will need to change these properties accordingly.
- We provide an optional `values` object to customize the Helm chart's deployed resources, which in this case is set to expose the ingress controller through a `LoadBalancer` service. The `values` object structure depends on the Helm chart's available configuration options.
- We're exporting the public IP address of the LoadBalancer service associated with the ingress controller so that we can use it to access our services from outside the Kubernetes cluster. This step assumes that your cloud provider supports LoadBalancer services and that the ingress controller creates a LoadBalancer service.
- If you have multiple Kubernetes providers, you can specify which provider to use by passing the `provider` argument.

Please adjust the Helm chart details, values, and other settings to fit your specific ingress controller's requirements. After defining this program in a `.ts` file, you can deploy it using `pulumi up` from your command line, which will execute the code and perform the deployment to your Kubernetes cluster.