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

Question

Pulumi · Accepted Answer

To deploy the `postgres-with-operator` Helm chart on Google Kubernetes Engine (GKE), you will perform the following steps:

1. Set up a GKE cluster where the Helm chart will be deployed.
2. Install the Helm chart on the GKE cluster.

For this task, we'll use a `google-native.container/v1beta1.Cluster` resource to create a GKE cluster. Then, we'll use the `kubernetes:helm.sh/v3:Chart` resource from Pulumi's Kubernetes provider to deploy the `postgres-with-operator` Helm chart on the created GKE cluster.

Below is a Pulumi program written in TypeScript that demonstrates how to accomplish the above steps. The program will first declare a GKE cluster and then deploy the Helm chart. I'll explain each part of the code in comments and provide explanations around the code as needed.

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

// Step 1: Provision a GKE cluster
const cluster = new gcp.container.Cluster("postgres-cluster", {
    // Configuring the location of the cluster to a specific region or zone
    location: "us-central1",
    // Defining the cluster settings like the initial node count and the machine type for the nodes
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

// After the cluster is created, we need to obtain the kubeconfig that will be used to interact with the cluster.
// We use Pulumi outputs to fetch the cluster name and the GKE endpoint and then construct the kubeconfig.
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
`;
});

// A Kubernetes provider instance is created using the obtained kubeconfig.
// This provider is used for deploying resources to the GKE cluster.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Step 2: Deploy the Helm chart
// Here we are using the Helm chart resource from Pulumi's Kubernetes provider to deploy `postgres-with-operator`.
const postgresChart = new k8s.helm.v3.Chart("postgres-chart", {
    chart: "postgres-operator",
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // You may need to pass specific configuration values for your Helm chart deployment.
}, { provider: k8sProvider });

// Export the cluster name and the Kubeconfig to use outside the Pulumi program
export const clusterName = cluster.name;
export const kubeConfigOutput = kubeconfig;
```

In this program:
- We establish a new `Cluster` resource called `postgres-cluster`. This is a GKE cluster that will have 2 nodes of type `n1-standard-1`.
- We construct a `kubeconfig` using the output from the cluster creation, which includes the cluster name, endpoint, and master's auth details. This is needed to communicate with the cluster via `kubectl`.
- Then we create a new instance of `Provider` from the `@pulumi/kubernetes` package, which allows Pulumi to deploy Kubernetes resources. We pass the `kubeconfig` to this provider.
- Following that, we create a `Chart` resource called `postgres-chart`, specifying the desired helm chart (`postgres-operator` from the `bitnami` repository). The exact chart name for `postgres-with-operator` will depend on the repository.
- Lastly, we export `clusterName` and `kubeConfigOutput`. These can be accessed after running `pulumi up` to interact with the cluster if needed.

Please ensure you have the requisite permissions and have set up the Pulumi CLI with your GCP account. Also, ensure Helm is installed and configured correctly in your environment.

To deploy this Pulumi program:
1. Create a new directory and `cd` into it.
2. Run `pulumi new typescript` and follow the prompts to create a new TypeScript Pulumi project.
3. Install the needed dependencies with npm:
   ```
   npm install @pulumi/pulumi @pulumi/gcp @pulumi/kubernetes
   ```
4. Replace the contents of `index.ts` with the code above.
5. Run `pulumi up` and confirm the deployment when prompted.

The `pulumi up` command will start the deployment process and provide status updates on the resources being provisioned. Once completed, you'll have a running GKE cluster and the `postgres-with-operator` Helm chart deployed. You can interact with your cluster using the outputted `kubeconfig`.