Deploy the openshift-serverless helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `openshift-serverless` Helm chart on Google Kubernetes Engine (GKE), Pulumi provides a streamlined and expressive way to create a GKE cluster and deploy Helm charts. Below I will guide you through the steps and explain the resources used to achieve your goal.

We will first create a GKE cluster. Once the cluster is up and running, we will use the Pulumi `Helm` resource to deploy the `openshift-serverless` Helm chart into our cluster.

### Creating a GKE Cluster

We will use the `google-native.container.v1.Cluster` resource from Pulumi's GCP Native provider to create a new GKE cluster. This resource allows us to define a Kubernetes cluster within GKE, specifying all necessary configuration like location, node pools, networking, etc.

### Deploying a Helm Chart

For deploying Helm charts, Pulumi provides a `Helm` resource as part of the `harness` package that can be used to deploy applications on Kubernetes using Helm. This resource allows us to deploy, upgrade, and manage Helm charts in a Kubernetes cluster in a declarative manner.

Here is a complete program demonstrating how to deploy the `openshift-serverless` Helm chart on GKE using Pulumi with TypeScript:

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        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
export const clusterName = cluster.name;

// Step 2: Setup K8s provider to the GKE cluster
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: cluster.endpoint.apply(endpoint => {
        return cluster.name.apply(name => {
            return cluster.masterAuth.apply(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 config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
            });
        });
    }),
});

// Step 3: Deploy the openshift-serverless Helm chart
const openshiftServerlessChart = new k8s.helm.v3.Chart("openshift-serverless", {
    chart: "openshift-serverless",
    fetchOpts: {
        repo: "https://your-helm-chart-repository-url", // Specify your Helm chart repository URL here
    },
    // Values to pass to the Helm chart values.yaml
    values: {
        
    },
}, { provider: k8sProvider });

// Export the Helm chart deployment name
export const openshiftServerlessChartName = openshiftServerlessChart.name;
```

### Explanation

- **GKE Cluster**: We create a new instance of `gcp.container.Cluster` to set up a GKE cluster. The configuration specifies the initial number of nodes, the machine type for our nodes, and the OAuth scopes required for GCP services that the cluster may interact with.

- **K8s Provider**: A Pulumi Kubernetes provider is instantiated with the `kubeconfig` created dynamically from the GKE cluster's info. This provider will enable us to interact with our Kubernetes cluster to deploy resources.

- **Helm Chart**: The `openshift-serverless` Helm chart is now deployed using `k8s.helm.v3.Chart`. This resource will install the Helm chart to the cluster with the specified values. Remember to replace `https://your-helm-chart-repository-url` with the actual Helm chart repository URL where the `openshift-serverless` chart is located.

Please note that you need to have `gcloud` CLI installed and configured on your system to authenticate against the GKE cluster using the method specified in the `kubeconfig` above.

To run the Pulumi program, save the code to a file (e.g., `index.ts`), and then execute it using the Pulumi CLI:

1. Navigate to the directory containing your `index.ts` file.
2. Run `pulumi up` to preview and deploy your changes.

It is important to highlight that the actual configuration might change based on the specifics of the `openshift-serverless` Helm chart and the requirements for your Kubernetes cluster. Be sure to adjust the values and the configurations accordingly.