Deploy the circleci-runner helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `circleci-runner` Helm chart on Google Kubernetes Engine (GKE), we'll follow these steps:

1. **Set up the GKE cluster**: We will create a GKE cluster where our application will be hosted.
2. **Install the Helm chart**: After setting up the cluster, we'll deploy the `circleci-runner` Helm chart to it.

Below is a Pulumi program written in TypeScript that accomplishes these steps. Ensure you have Pulumi installed and configured with appropriate access for Google Cloud.

### Detailed Program Explanation

- We first import necessary Pulumi libraries for GCP and Kubernetes.
- We use the `gcp.container.Cluster` class from the Pulumi GCP provider to create a new Kubernetes cluster. This class handles the provisioning of the GKE cluster.
- We then create a Kubernetes provider using `kubernetes.Provider`. This is configured to connect to the newly created GKE cluster.
- Finally, we use the `kubernetes.helm.v3.Chart` class to deploy the `circleci-runner` Helm chart onto the GKE cluster. We can customize the deployment by specifying `values` which correspond to the Helm chart's configurable values.

Here's the TypeScript program:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("circleci-runner-cluster", {
  initialNodeCount: 1,
  minMasterVersion: "latest",
  nodeConfig: {
    machineType: "n1-standard-1", // You can choose the machine type that suits your needs
    oauthScopes: [
      "https://www.googleapis.com/auth/cloud-platform",
    ],
  },
});

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

// Create a Kubernetes provider instance that uses our cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
  kubeconfig: kubeconfig,
});

// Deploy the circleci-runner Helm chart
const chart = new k8s.helm.v3.Chart("circleci-runner", {
  chart: "circleci-runner", // The name of the chart
  version: "0.2.0", // Specify the version of the chart you want to deploy
  fetchOpts: {
    repo: "https://circleci.github.io/helm-charts", // The repository where the chart is located
  },
}, { provider: k8sProvider });

// Export the Helm chart's status
export const chartStatus = chart.status;
```

### Explanation of Exports

- `clusterName`: This output variable will give you the name of the created GKE cluster.
- `kubeconfig`: This configuration output can be used to connect to the created GKE cluster with `kubectl` or any Kubernetes tooling.
- `chartStatus`: This output will provide information about the deployment status of your Helm chart.

Make sure to replace `"0.2.0"` with the desired version of the Helm chart that you wish to deploy.

### Next Steps

Once you have this Pulumi program, you can run the following commands to deploy your GKE cluster and Helm chart:

1. Initialize a new Pulumi project in an empty directory:

```sh
   pulumi new typescript
   ```

2. Paste the provided TypeScript code into `index.ts` in your new Pulumi project directory.

3. Run the following command to install the dependencies:

```sh
   npm install @pulumi/pulumi @pulumi/gcp @pulumi/kubernetes
   ```

4. Log in to the Pulumi service:

```sh
   pulumi login
   ```

5. Set up Google Cloud credentials in your environment, for example by using `gcloud auth`.

6. Deploy your stack with the following command, which will provision all the resources defined in the program:

```sh
   pulumi up
   ```

The program will output the GKE cluster name once the operation is complete. You can then manage your cluster and Helm chart deployment using Pulumi's CLI tools or directly through Google Cloud Console and Kubernetes tooling.