Deploy the knative-installer helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `knative-installer` Helm chart on Google Kubernetes Engine (GKE), you'll first need to create a GKE cluster. After the cluster is up and running, you can use Pulumi's Kubernetes provider to deploy the Helm chart to that cluster.

Below is a TypeScript program using Pulumi to accomplish this. This program will:

1. Create a GKE cluster using GCP's `container.Cluster` resource.
2. Deploy the `knative-installer` Helm chart using Pulumi's `kubernetes.helm.v3.Chart` resource.

Make sure you have Pulumi installed and configured to use your GCP credentials before running this program.

### Detailed Steps:

1. **Define the GKE Cluster**: This uses the `gcp.container.Cluster` resource to create a new GKE cluster with the necessary configuration for Knative.

2. **Define the Kubernetes Provider**: Once the GKE cluster is ready, we set up a Kubernetes provider that points to the created GKE cluster. This provider is used for subsequent Kubernetes-related operations.

3. **Deploy Knative Helm Chart**: We use the `kubernetes.helm.v3.Chart` resource to deploy Knative to our GKE cluster using a Helm chart. The Helm chart's name is `knative-installer`, and you'll need to provide the Helm repository where this chart is hosted.

Please note that Helm charts often have their own set of configurable values. You may need to set specific values for the `knative-installer` chart depending on your requirements. In the example below, replace `CHART_VERSION` with the actual version of the chart you wish to deploy, and similarly, replace `HELM_REPO_URL` with the URL of the Helm repository containing the `knative-installer` chart.

Here's the complete program:

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

// Step 1: Create the GKE cluster
const cluster = new gcp.container.Cluster("knative-gke-cluster", {
    initialNodeCount: 3,
    nodeConfig: {
        oauthScopes: [
            "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 and Kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config view --minify --flatten --output=jsonpath='{.users[].user.auth-provider.config}'
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });

// Step 2: Setup the Kubernetes Provider
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy Knative using Helm Chart
const knative = new k8s.helm.v3.Chart("knative", {
    chart: "knative-installer",
    version: "CHART_VERSION", // Specify the chart version
    fetchOpts: {
        repo: "HELM_REPO_URL", // Specify the Helm repository URL
    },
}, { provider: k8sProvider });

// Export the Helm chart name
export const knativeChartName = knative.releaseName;
```

You’ll run this program using the Pulumi CLI. When you execute `pulumi up`, Pulumi will communicate with GCP to create the resources you’ve declared in the program. After the GKE cluster is up and running, Pulumi will deploy Knative to that cluster using the Helm chart.

Keep in mind that Knative also requires Istio or a similar service mesh to work correctly, so you might need to deploy that into your cluster as well, depending on the configurations of the `knative-installer` chart.

This program should get you started, but remember that you will need to configure your resources and Helm chart according to your specific needs, which may require setting additional properties or adjusting the provided configuration.