Deploy the unleash-proxy helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `unleash-proxy` Helm chart on Google Kubernetes Engine (GKE), we'll need to accomplish a few high-level tasks:

1. Set up a GKE cluster.
2. Deploy the Helm chart to the cluster.

We'll use Pulumi with TypeScript to manage the resources. First, ensure you have Pulumi CLI installed and configured with GCP credentials.

Now, let's set up a GKE cluster using Pulumi. For this, we will use the `gcp.container.Cluster` class from the `@pulumi/gcp` package. This class allows us to define and manage a GKE cluster.

After the cluster is set up, we will deploy the `unleash-proxy` Helm chart using the `kubernetes.helm.v3.Chart` class from the `@pulumi/kubernetes` package. This class is a high-level interface for deploying Helm charts to a Kubernetes cluster.

Here is a step-by-step TypeScript program that performs these tasks:

```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("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;

// Export the Kubeconfig to access the Cluster
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 provider for the new cluster
const gkeProvider = new k8s.Provider("gke-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the unleash-proxy Helm chart to the cluster
const unleashProxyChart = new k8s.helm.v3.Chart("unleash-proxy", {
    chart: "unleash-proxy",
    version: "1.0.0", // specify the version of the chart you want to deploy
    fetchOpts: {
        repo: "http://myhelmrepo.com/charts", // replace with the correct Helm repo URL
    },
}, { provider: gkeProvider });

// Export the public IP of the Unleash Proxy service
export const unleashProxyIp = unleashProxyChart.getResourceProperty("v1/Service", "unleash-proxy", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

```

In this program, we first define a `Cluster` resource for GKE. We specify the desired node count, the machine type for the nodes, and the OAuth scopes required for the nodes to interact with other Google Cloud services.

The `kubeconfig` output provides the necessary data to configure your local `kubectl` client to interact with the new GKE cluster.

Next, we create a Kubernetes Provider, `gkeProvider`, which uses the `kubeconfig` for the newly created GKE cluster. This provider is what Pulumi will use to interact with the cluster.

We then declare a Chart resource named `unleash-proxy`, specifying the chart name and version. Make sure to replace the `repo` in `fetchOpts` with the actual Helm repository URL where the `unleash-proxy` chart is located.

Finally, we export the public IP address of the `unleash-proxy` service once the Helm chart has been deployed, which enables you to access the Unleash Proxy service from the internet.

To run this program:
- Save the code to a file named `index.ts`.
- Run `pulumi up` to preview and deploy the changes.

If you have not set up Pulumi or GCP credentials, please refer to Pulumi's [GCP Getting Started](https://www.pulumi.com/docs/get-started/gcp/) guide and the [Pulumi Installation](https://www.pulumi.com/docs/get-started/install/) guide.

Make sure you have Helm installed and initialized as well, as Pulumi would use Helm to deploy charts to the Kubernetes cluster.