Deploy the postgres-cluster helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a PostgreSQL cluster using a Helm chart on Google Kubernetes Engine (GKE), you will need to perform the following steps:

1. Create a GKE cluster, if you don't already have one.
2. Configure kubectl to connect to your GKE cluster.
3. Install Helm, a package manager for Kubernetes, if it's not already installed.
4. Add the repository that contains the PostgreSQL Helm chart, if not already added.
5. Install the PostgreSQL Helm chart.

In the program below, we will start by setting up a GKE cluster using Pulumi’s GCP provider. After the cluster is provisioned, we'll use Pulumi’s Helm provider to deploy PostgreSQL using a Helm chart on the newly created cluster.

Here's the complete Pulumi program in TypeScript which accomplishes this:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("postgres-cluster", {
    initialNodeCount: 3,
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

// 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, auth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.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 instance that uses our cluster from above.
const clusterProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Install the PostgreSQL Helm chart using the Helm provider.
const postgresql = new k8s.helm.v3.Chart("postgresql-chart", {
    chart: "postgresql",
    version: "10.3.11", // Specify the version of the chart to install.
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: clusterProvider });

// Export the Helm chart values, including the namespace and service information
export const postgresqlValues = postgresql.resourceNames;
```

In this program:

- We're importing the necessary Pulumi packages for the GCP provider (`@pulumi/gcp`), Kubernetes (`@pulumi/kubernetes`), and Pulumi itself (`@pulumi/pulumi`).

- We create a GKE cluster with a specified amount (`initialNodeCount`) of nodes using a given machine type. Adjust these settings according to your needs.

- We generate a kubeconfig that can be used with `kubectl` to interact with the cluster outside of Pulumi, and we export it.

- We instantiate the Kubernetes provider with the created kubeconfig, which allows Pulumi to deploy Kubernetes resources onto the GKE cluster.

- We deploy PostgreSQL using the `postgresql` Helm chart from the Bitnami repository, specifying the version of the chart we want to use.

- The Helm chart parameters are configured within the `k8s.helm.v3.Chart` resource instantiation, where you can customize the PostgreSQL deployment to your liking.

- We export the names of the resources created by the Helm chart to be able to refer or manage them later.

To deploy this infrastructure, you would save this code to a `index.ts` file and run the following commands in your terminal:

```
pulumi up
```

This command will provision the resources as described in the code. Make sure you have Pulumi CLI installed and GCP credentials configured. You can follow the [Pulumi installation guide](https://www.pulumi.com/docs/get-started/install/) and [GCP configuration guide](https://www.pulumi.com/docs/intro/cloud-providers/gcp/setup/) for more details. Once the GKE cluster and PostgreSQL are deployed, you can manage them using `kubectl`, Pulumi, or the GCP console.