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

Question

Pulumi · Accepted Answer

To deploy the `redis-ui Helm chart` on `Google Kubernetes Engine (GKE)`, we'll follow several steps:

1. We'll create a GKE cluster using Pulumi's GKE support.
2. We'll use Pulumi's Helm chart support to deploy the `redis-ui` chart on the created GKE cluster.

We'll be making use of the `@pulumi/gcp` and `@pulumi/kubernetes` packages. The `@pulumi/gcp` package will allow us to create resources on Google Cloud Platform (GCP), like a GKE cluster. The `@pulumi/kubernetes` package will allow us to interact with Kubernetes, including deploying a Helm chart.

Before we start, ensure that you have installed Pulumi and configured your GCP credentials. You should have a GCP project and the `gcloud` CLI installed and configured for your environment.

Now, let's move on to the Pulumi program:

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

// Step 1: Create a GKE cluster
const engineVersion = gcp.container.getEngineVersions({}).then(v => v.latestMasterVersion);

const cluster = new gcp.container.Cluster("redis-cluster", {
    initialNodeCount: 2,
    minMasterVersion: engineVersion,
    nodeVersion: engineVersion,
    nodeConfig: {
        // Be sure to choose the machine type that suits your needs and budget
        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 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
`;
    });

// Step 2: Deploy the redis-ui Helm chart on the created GKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeConfig,
});

const redisUiChart = new k8s.helm.v3.Chart("redis-ui", {
    chart: "redisplay",
    version: "1.0.0", // Use the appropriate chart version
    fetchOpts: {
        repo: "https://charts.example.com/", // Update with the correct Helm repo URL for redis-ui
    }
}, { provider: k8sProvider });

// Export the Redis UI service endpoint
export const redisUiService = redisUiChart.getResource("v1/Service", "redis-ui");

```

This Pulumi program consists of two main parts:

1. **GKE Cluster Creation**: We create a GKE cluster using `gcp.container.Cluster`. We configure it to have initial two nodes, using a specific machine type. Modify `machineType` as well as `initialNodeCount` based on your requirements and budget. The cluster version is automatically set to the latest available at the time of creation.

2. **Deploying Redis UI Helm Chart**: We deploy the `redis-ui` chart using Pulumi's `k8s.helm.v3.Chart`. You'll need the exact name of the chart and the Helm repository where it's hosted. You might need to customize the `version` and `fetchOpts.repo` according to the available Redis UI Helm chart.

3. **Exporting Configuration**: The GKE cluster's name and endpoint along with the necessary authentication tokens are combined together to form a `kubeconfig` that Pulumi uses for managing Kubernetes resources (e.g., deploying the Helm chart). We also export the service endpoint for Redis UI for easy access after deployment.

When you run `pulumi up`, Pulumi creates the resources in the specified order, and outputs are shown at the end of the operation which includes the `clusterName` and the endpoint for the `redisUiService`. You can use the `kubeConfig` output when manually interacting with the cluster using `kubectl`.

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

```sh
pulumi stack init dev
pulumi up
```

Please make sure you replace the placeholder values such as the version number `1.0.0` and `https://charts.example.com/` with actual values relevant to the redis-ui Helm chart.