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

Question

Pulumi · Accepted Answer

To deploy the `redis-persistent` Helm chart on Google Kubernetes Engine (GKE), you need to follow these steps:

1. Set up a GKE cluster.
2. Configure Pulumi to use the correct GCP project and region where the GKE cluster is located.
3. Use Pulumi's Kubernetes provider to interact with the GKE cluster.
4. Use Pulumi's Helm package to deploy the `redis-persistent` chart from the stable Helm chart repository.

First, ensure you have installed Pulumi and configured it with GCP credentials. Next, you'll need to set the appropriate configuration for your GCP project, and the Pulumi stack region where you want to deploy the GKE cluster.

Below is a Pulumi program written in TypeScript that will set up a GKE cluster and deploy the `redis-persistent` Helm chart onto it:

```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('redis-cluster', {
    initialNodeCount: 2,
    nodeVersion: 'latest',
    minMasterVersion: 'latest',
    nodeConfig: {
        // Specify the amount of memory and CPU for each node in the cluster.
        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
`;
    });

// Create a Kubernetes Provider referencing the new Kubeconfig
const k8sProvider = new k8s.Provider('k8s-provider', {
    kubeconfig: kubeConfig,
});

// Deploy the redis-persistent Helm chart inside the GKE cluster
const redisPersistent = new k8s.helm.v3.Chart('redis-persistent', {
    chart: 'redis',
    version: '10.5.7', // use the version that suits your needs
    fetchOpts:{
        repo: 'https://charts.bitnami.com/bitnami',
    },
    values: {
        // Values to override the default chart values.
        // Refer to the chart's documentation for the full list of options.
        usePassword: false,
        cluster: {
            enabled: true,
            slaveCount: 1,
        },
        persistence: {
            enabled: true,
            size: '10Gi', // The size of storage to allocate to each Redis pod.
        },
    },
}, { provider: k8sProvider });

// Export the Redis master service endpoint
export const redisMasterServiceEndpoint = redisPersistent.getResource('v1/Service', 'redis-persistent-master').status.apply(s => s.loadBalancer.ingress[0].ip);
```

This Pulumi program will:

- Provision a new GKE cluster with two nodes using the `gcp.container.Cluster` class. The settings for the node size and OAuth scopes are specified in the `nodeConfig` property.
- Generate the kubeconfig file required to interact with the GKE cluster.
- Create a new instance of the `k8s.Provider` class which uses our generated kubeconfig.
- Deploy the `redis-persistent` Helm chart to the GKE cluster using Pulumi's `k8s.helm.v3.Chart` class. Here we're specifying the chart name, version and overrides for the chart values. We're also providing the properly configured Kubernetes provider to this Helm chart.
- Export the Redis master service endpoint which represents the way to interact with the Redis deployment from outside the GKE cluster.

Remember to replace the `version` of the `redis` Helm chart with the one you want to deploy, and adjust the values in the `values` property as per your requirements.

Before you run `pulumi up` with this program, make sure you've setup the correct Pulumi stack and authenticated it with GCP. Once this command is executed, Pulumi will begin provisioning the resources on GCP. After the deployment, the Redis master service endpoint will be printed as an output.