Deploy the ingress-controller helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy an ingress-controller Helm chart on Google Kubernetes Engine (GKE), we will perform the following steps:

1. Create a GKE cluster: This is the Kubernetes cluster provided by Google Cloud where your workloads will run.
2. Deploy the ingress-controller: We will use the Helm package manager for Kubernetes to deploy an ingress-controller chart, which will allow you to manage external access to the services in the cluster via HTTP.

We will be making use of the following Pulumi resources:

- `google-native.container.v1beta1.Cluster`: This resource will create the GKE cluster.
- `kubernetes-ingress-nginx.IngressController`: We will utilize this resource, which is a Pulumi abstraction over the ingress-nginx Helm chart, to deploy the ingress-controller.

Here is your detailed program written in TypeScript:

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest available version of GKE
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // This is the type of machine to use for nodes
        oauthScopes: [              // Set of scopes to be made available on all of the node VMs
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Step 2: Deploy the ingress-nginx controller using Helm
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify), // Pass the kubeconfig of the GKE cluster to the k8s provider
});

const ingressController = new k8s.helm.v3.Chart("nginx-ingress", {
    chart: "ingress-nginx",
    fetchOpts:{
        repo: "https://kubernetes.github.io/ingress-nginx",
    },
}, { provider: k8sProvider });

// Export the ingress controller status
export const ingressStatus = ingressController.status;
```

### Explanation:

- We start by importing the necessary libraries from Pulumi to create resources in Google Cloud Platform (GCP) and to work with Kubernetes and Helm charts.

- We set up a new GKE cluster with `gcp.container.Cluster`. Note that we choose at least two nodes for our cluster and specify a machine type that denotes the compute resources available to each node. We also add OAuth scopes to describe the permissions for GCP services needed by the nodes.

- The `kubeconfig` of the created cluster is then used to configure the Pulumi Kubernetes provider which allows Pulumi to communicate with our GKE cluster.

- With the Kubernetes provider configured, we can now define a `k8s.helm.v3.Chart` resource to deploy our ingress-controller. We specify the name of the chart and the repository it can be found in.

- Lastly, we export the cluster name and the ingress controller's status. This can be helpful if you want to interact with your cluster or helm chart using other tools or need to verify the deployment's success.

This program will set up your GKE cluster and deploy an ingress controller onto it, and it assumes you have Pulumi CLI installed and configured with GCP credentials. Save your TypeScript code to a file (e.g., `index.ts`), and then simply run `pulumi up` to execute it. Pulumi will show you a preview and then carry out the deployment when you confirm. After the program completes, you should have a fully functioning ingress controller on your GKE cluster.