Deploy the simple-redis helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `simple-redis` Helm chart on Google Kubernetes Engine (GKE), you'll need to complete a few steps:

1. **Set up a GKE cluster**: Provision a Kubernetes cluster on GKE where your Helm chart will be deployed.
2. **Install the Helm chart**: After setting up the cluster, use Pulumi to install the `simple-redis` Helm chart onto the GKE cluster.

We'll use the `@pulumi/gcp` package to create a GKE cluster and the `@pulumi/kubernetes` package to apply the Helm chart.

Below is a Pulumi program written in TypeScript that accomplishes these steps:

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

// Step 1: Creating a GKE cluster
const cluster = new gcp.container.Cluster("simple-redis-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "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;

// Obtain the Kubeconfig for the newly created GKE cluster
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
`;
    });

// Step 2: Install the simple-redis Helm chart on the GKE cluster
const simpleRedisChart = new k8s.helm.v3.Chart("simple-redis", {
    chart: "redis",
    version: "10.5.7", // specify the version of the chart to install
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami", // specify the Helm chart repository
    },
}, { provider: new k8s.Provider("k8s-provider", {kubeconfig}) });

// Export the Redis service endpoint
export const redisServiceEndpoint = simpleRedisChart.getResourceProperty("v1/Service", "simple-redis-redis-master", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

Here's what each part of this program does:

- We define a GKE cluster with `initialNodeCount` set to 2, representing the number of worker nodes in the cluster.
- We set `minMasterVersion` and `nodeVersion` to `latest` to ensure that the cluster uses the latest available version.
- In `nodeConfig`, we specify the type of machine to use and the OAuth scopes needed for the GKE nodes to interact with Google Cloud services.
- We export the `clusterName` which will be the name of our GKE cluster.
- We construct a `kubeconfig` that is required to communicate with the cluster with Pulumi's Kubernetes provider.
- We define the `simpleRedisChart` as a resource that represents the `simple-redis` Helm chart. Here, we specify the chart name (`redis`), the chart version, and the repository where the chart can be found.
- We provide the `kubeconfig` to the Kubernetes provider so Pulumi can communicate with the new GKE cluster and install the Helm chart.
- Lastly, we export the `redisServiceEndpoint` which is the external IP address for the Redis service. You can use this IP address to connect to your Redis instance.

After the program runs successfully, you'll have a Redis instance running on your GKE cluster, and the output will show the IP address you can use to connect to it. To run this program, you'll need to have Pulumi CLI installed and configured for both GCP and Kubernetes access. Save the code to a file with a `.ts` extension, and run `pulumi up` to start the deployment.