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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps. First, we need to create a GKE cluster if one doesn't already exist. Then, once we have a Kubernetes cluster, we can proceed with the installation of the Helm chart.

In Pulumi, creating infrastructure is handled by defining resources in a Pulumi program. Resources are objects that represent a piece of infrastructure in the cloud, such as a Kubernetes cluster or a Helm Release.

Below, we'll go through a Pulumi TypeScript program that creates a GKE cluster and then uses the Helm chart to deploy the `nearbyone-controller`. We'll use the `@pulumi/gcp` package to create the cluster, and the `@pulumi/kubernetes` package to handle the Helm chart deployment.

Let's start by creating a new GKE cluster:

### Step 1: Create a GKE Cluster

To define a GKE cluster in Pulumi, we'll use the `gcp.container.Cluster` resource, which corresponds to a GKE cluster in Google Cloud Platform.

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

// 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"
        ],
    },
});
```

### Step 2: Configure K8s Provider

After creating the GKE cluster, we'll set up the Kubernetes provider. The provider uses the cluster's kubeconfig to interact with the Kubernetes API. Pulumi will automatically generate the kubeconfig for the created GKE cluster.

```typescript
// Create an instance of the Kubernetes Provider configured with the GKE cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: cluster.endpoint.apply(endpoint => {
        return cluster.masterAuth.apply(masterAuth => {
            const context = `gke_${gcp.config.project}_${cluster.location}_${cluster.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: gcloud
`;
        });
    }),
});
```

### Step 3: Deploy Helm Chart

Finally, we will define a Helm chart resource to deploy the `nearbyone-controller`. In this case, we are assuming that the chart is available in a Helm repository. If the chart is not in a repository, you would need to specify the path to the chart directory.

```typescript
// Deploy the nearbyone-controller Helm chart
const nearbyoneControllerChart = new k8s.helm.v3.Chart("nearbyone-controller", {
    chart: "nearbyone-controller",
    version: "1.0.0", // specify the exact chart version
    fetchOpts:{
        repo: "http://charts.nearbyone.com/", // specify the Helm chart repository URL
    },
}, { provider: k8sProvider });
```

### Complete Program

Here is the complete program composed of the three steps mentioned above. This program will create the necessary GKE cluster and deploy the `nearbyone-controller` Helm Chart to it.

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

// 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"
        ],
    },
});

// Step 2: Set up the Kubernetes Provider
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: cluster.endpoint.apply(endpoint => {
        return cluster.masterAuth.apply(masterAuth => {
            const context = `gke_${gcp.config.project}_${cluster.location}_${cluster.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: gcloud
`;
        });
    }),
});

// Step 3: Deploy the nearbyone-controller Helm chart
const nearbyoneControllerChart = new k8s.helm.v3.Chart("nearbyone-controller", {
    chart: "nearbyone-controller",
    version: "1.0.0", // specify the exact chart version
    fetchOpts:{
        repo: "http://charts.nearbyone.com/", // specify the Helm chart repository URL
    },
}, { provider: k8sProvider });
```

To run this Pulumi program, you would typically use the `pulumi up` command in your terminal. This command automatically provisions the resources as defined in the code and reports the progress in the terminal window.

Please note, for any real-world usage you would want to manage sensitive information like kubeconfig with a more secure approach and potentially look at private clusters or hardened security settings depending on your use case.

For more information on using Pulumi with GKE and Kubernetes, you can visit the [Pulumi documentation for GCP](https://www.pulumi.com/docs/intro/cloud-providers/gcp/) and the [Pulumi API documentation for Kubernetes](https://www.pulumi.com/docs/reference/pkg/kubernetes/helm/v3/chart/).