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

Question

Pulumi · Accepted Answer

To deploy the `openshift-gitops-instance` helm chart on Google Kubernetes Engine (GKE), we will need to carry out the following steps using Pulumi with TypeScript:

1. Create a GKE cluster.
2. Install and configure Helm.
3. Use the Helm chart resource to deploy `openshift-gitops-instance`.

Below, you'll find a detailed Pulumi program written in TypeScript that accomplishes these steps.

### Pulumi Program Explanation

#### Step 1: Create a GKE Cluster
We start by defining a GKE cluster resource. This will set up a Kubernetes cluster in GCP for us. In the definition, we specify the required configuration such as the GKE cluster name, the node count, and the machine types for our nodes.

#### Step 2: Install and Configure Helm
With our cluster set up, we next install Helm and provide it with the necessary configuration so that it can interact with the Kubernetes API server. This is handled by creating a Helm Release resource.

#### Step 3: Deploy the Helm Chart
Finally, we define a Helm chart resource which specifies the `openshift-gitops-instance` chart and assigns it to our GKE cluster. Here, you may need to specify the correct repository and version depending on the Helm chart's availability.

Throughout the code, we will use components from the `@pulumi/kubernetes` and `@pulumi/gcp` packages.

### Pulumi TypeScript Program

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1", // You can choose your machine type
    },
});

// Export the Kubeconfig
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 config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
});

// Configure Kubernetes provider to connect to the GKE cluster
const k8sProvider = new kubernetes.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the openshift-gitops-instance Helm chart
const gitopsChart = new kubernetes.helm.v3.Chart("openshift-gitops-instance", {
    chart: "openshift-gitops-instance",
    version: "1.0.0", // Specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://charts.openshift.io/", // Specify the repository that holds the chart
    },
}, { provider: k8sProvider });

```

This program creates a GKE cluster, installs Helm, and deploys the `openshift-gitops-instance` chart. You must replace the `version` and `repo` with the appropriate values for the chart you wish to deploy.

### Outputs and Exports

In the program, you'll notice we export a `kubeconfig`. This configuration file is used by `kubectl` and other tools to interact with the Kubernetes cluster.

### Next Steps

After running this program using the Pulumi CLI, your GKE cluster and Helm chart will be deployed. You can then interact with your cluster using `kubectl` by setting up your local `kubeconfig` file with the data exported from the program.

**Note:** Ensure you have Helm installed on your machine if you intend to use it locally to interact with the Kubernetes cluster created by Pulumi.

Ensure you have the correct permissions on your GCP account to create GKE clusters and deploy Helm charts. If this is your first time running Pulumi, you might need to log in to Pulumi and set up the GCP credentials. Refer to the Pulumi documentation on [setting up GCP credentials](https://www.pulumi.com/docs/intro/cloud-providers/gcp/setup/).

### Running the Program with Pulumi

To run the Pulumi program, save the file with a `.ts` extension, then execute the following commands:

```sh
pulumi stack init dev        # Initializes your Pulumi stack
pulumi up                    # Review and deploy changes
```

These will initialize a new Pulumi stack called `dev` and start the deployment process, respectively. You'll be prompted to review the changes before applying them.

Remember that using resources on GCP may incur charges, so be sure to delete the resources when you're done experimenting to avoid any unexpected costs:

```sh
pulumi destroy               # Tear down all resources
```

This command undoes the deployment and tears down all the resources you created with the program.