Deploy the storage helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a storage Helm chart on Google Kubernetes Engine (GKE), you'll first need to create a GKE cluster, then configure your Pulumi environment to deploy Helm charts using the Helm Release resource provided by Pulumi.

Below is a Pulumi program in TypeScript that creates a GKE cluster and deploys a Helm chart within it. Before diving into the code, let's break down the steps:

1. **Set Up the GKE Cluster**: We'll define a GKE cluster using Pulumi's `gcp.container.Cluster` resource. Ensure that you have the required permissions and have configured Pulumi with your GCP credentials.

2. **Install the Helm Chart**: After the cluster is ready, we'll install a Helm chart to deploy the storage solution. We will use Pulumi's Helm Release resource, which is provided by the `@pulumi/kubernetes` package.

Here's how you can write the program:

```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("my-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    location: "us-central1-a",
    nodeConfig: {
        // When specifying a machine type, ensure it has enough resources for your workloads.
        machineType: "n1-standard-1", // or another machine type
        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 for local access
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: Install the Helm chart into the GKE cluster
// Configure the Kubernetes provider with the kubeconfig from the newly created GKE cluster
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy a Helm chart, for example a Redis chart as our storage solution
const redisChart = new k8s.helm.v3.Release("redis", {
    chart: "redis",
    version: "10.5.7", // Specify the chart version you wish to deploy
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // Define values for the Helm chart in values yaml or pass them in an object directly
    values: {
        // These values would be specific to the storage chart you want to install
        // For demonstration, these are example values that might be used for a Redis chart.
        cluster: {
            enabled: true,
        },
        metrics: {
            enabled: true,
        },
    },
}, { provider: k8sProvider });

// Export the Redis Helm chart service IP
export const redisServiceIp = redisChart.status.apply(status => status.service.apply(s => s.loadBalancer.apply(lb => lb.ingress[0].ip)));
```

Before you run the code, you need to have Pulumi and GCP CLI tools installed and configured properly.

### Prerequisites:
- Install [Pulumi](https://www.pulumi.com/docs/get-started/install/).
- Install [Google Cloud SDK (gcloud)](https://cloud.google.com/sdk/docs/quickstarts).
- Authenticate with Google Cloud: run `gcloud auth login` and `gcloud config set project [PROJECT_ID]`.
- Ensure your Google Cloud account has the appropriate roles and permissions to create GKE clusters and work with Google Container Registry.

### Running the Code:
Once you're set up with all prerequisites, here are the general steps to run the code:
1. Save the above TypeScript code to a file named `index.ts`.
2. Create a new Pulumi project with `pulumi new typescript` (pick an appropriate project and stack name when prompted).
3. Place the `index.ts` file in your Pulumi project directory.
4. Run `npm install` to install all necessary packages.
5. Finally, deploy your infrastructure with the command `pulumi up`.

This script would create the GKE cluster and deploy the specified Helm chart (in the script provided, a Redis database). Remember that in the `values` section under the Redis Helm chart deployment, you need to specify the appropriate values for the storage solution you are deploying.