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

Question

Pulumi · Accepted Answer

To deploy the `redis-sentinel` Helm chart on Google Kubernetes Engine (GKE) using Pulumi, we need to accomplish the following:

1. Create a GKE cluster where the Helm chart will be deployed.
2. Install the Helm chart into the created GKE cluster.

For the deployment, we will use the `@pulumi/gcp` and the `@pulumi/kubernetes` packages. The `@pulumi/gcp` package allows us to create and manage Google Cloud resources, such as a GKE cluster. The `@pulumi/kubernetes` package provides a way to deploy Helm charts among other Kubernetes resources.

Here's a step-by-step Pulumi program in TypeScript to perform this task:

### Step 1: Install Pulumi Packages

Make sure to install the necessary Pulumi packages:

```bash
 npm install @pulumi/pulumi @pulumi/gcp @pulumi/kubernetes
 ```

### Step 2: Setup the Pulumi Program

In the following program, we will:

1. Import the necessary modules from the Pulumi library.
2. Set up the GKE cluster.
3. Configure the Kubernetes provider to interact with the created GKE cluster.
4. Use the Kubernetes provider to deploy the `redis-sentinel` Helm chart.

Here's the full Pulumi program in TypeScript:

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-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"
        ],
    },
});

// Step 2: Configure the Kubernetes provider to use the GKE cluster credentials
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: cluster.endpoint.apply(endpoint => {
        return cluster.masterAuth.apply(masterAuth => {
            const context = `${gcp.config.project}_${gcp.config.zone}_${cluster.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 3: Deploy the redis-sentinel Helm chart on the GKE cluster
const redisSentinelChart = new k8s.helm.v3.Chart("redis-sentinel", {
    chart: "redis",
    version: "10.5.7", // Specify the version of the chart that includes Sentinel
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        sentinel: {
            enabled: true,
        },
    },
}, { provider: k8sProvider });

// Export the cluster's name and Kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = k8sProvider.kubeconfig;
```

### Explanation:

- We start by importing the Pulumi SDK and the necessary GCP and Kubernetes modules for handling resources.
- We then define a GKE cluster `gke-cluster` with two nodes using the `n1-standard-1` machine type. It is advisable to check for the appropriate machine types and OAuth scopes as per your requirements.
- The `kubeconfig` for the Kubernetes provider is generated dynamically using the GKE cluster's endpoint and cluster master authentication data.
- The provider `gke-k8s` uses this `kubeconfig` which allows the Pulumi Kubernetes SDK to deploy resources to our GKE cluster.
- We create a new Helm chart resource named `redis-sentinel` using the `redis` chart from Bitnami's Helm repository. We enable Sentinel by setting the `sentinel.enabled` value.
- Finally, we export the cluster name and the kubeconfig.

After setting up this Pulumi program, you can run `pulumi up` to provision the resources on GCP and deploy the `redis-sentinel` Helm chart. After the deployment, Pulumi will output the exported cluster name and the kubeconfig, which you can use to interact with your Kubernetes cluster.