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

Question

Pulumi · Accepted Answer

To deploy the Redis Cache Helm chart on Google Kubernetes Engine (GKE), you need to perform the following high-level steps:

1. **Set up a GKE cluster**: Before you can deploy the Helm chart, you need a running Kubernetes cluster. You can create a new cluster using Pulumi's GCP package.
2. **Install and configure Helm**: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications. For Helm to work with your GKE cluster, it needs to be installed on your local machine or within a CI/CD environment, and you need to configure it to communicate with your GKE cluster.
3. **Deploy the Redis Helm chart**: Once Helm is set up, you can use it to deploy the Redis chart from a chart repository to your cluster.

Below is a Pulumi program written in TypeScript that sets up a GKE cluster and deploys the Redis Helm chart. It assumes you have Pulumi installed, along with access to a Google Cloud account. The Google Cloud SDK should be authorized to access your account as usual, and the Pulumi CLI should be logged in.

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("redis-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest GKE version available
    nodeVersion: "latest",
    nodeConfig: {
        // Using a machine type with sufficient resources for Redis
        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 using kubectl
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 that uses our cluster's kubeconfig.
const provider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Redis helm chart using the Helm provider
const redisChart = new k8s.helm.v3.Chart("redis-cache", {
    chart: "redis",
    version: "15.3.1", // You can specify the Redis chart version you want to deploy
    fetchOpts: {
        // Optional: Fetch the chart from a specified Helm chart repository
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider });

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

### Explanation

- We're creating a GKE cluster with `gcp.container.Cluster`. The chosen machine type `n1-standard-1` should be sufficient for hosting a small Redis cache.
- We configure the `oauthScopes` to give Kubernetes nodes the necessary Google Cloud permissions.
- The `kubeconfig` variable is structured to interact with the cluster using `kubectl`.
- We create a Pulumi Kubernetes provider that points to our GKE cluster. The provider will use the generated `kubeconfig` to interact with the cluster.
- We then deploy the Redis chart using the `k8s.helm.v3.Chart` resource from the Pulumi Kubernetes package. We specify the chart name `redis`, the version, and the repository URL where the Redis Helm chart is located.
- Finally, we export the endpoint of the Redis server service which can be used to connect to the Redis cache once the deployment is complete.

Remember to have Helm and `gcloud` command-line tools installed, and you must be authenticated to the cluster for Helm to interact with it.