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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps using Pulumi. First, a GKE cluster is created. After the cluster is available, the Helm chart is deployed to the cluster. In this case, we will deploy the `postgresql-persistent` Helm chart, which will provision a PostgreSQL database with persistent storage.

Let's go through the steps of the Pulumi program written in TypeScript:

1. **Set up the GKE cluster**: Use the `gcp.container.Cluster` resource to create a new GKE cluster.

2. **Configure the Kubernetes provider**: Once the GKE cluster is created, you'll need to configure the Kubernetes provider to deploy resources into that cluster.

3. **Deploy the Helm chart**: Use the `kubernetes.helm.v3.Chart` resource to deploy the `postgresql-persistent` Helm chart into the GKE cluster.

Here is the complete Pulumi program. Make sure to have Pulumi and the required GCP and Kubernetes providers configured before running this code:

```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("postgresql-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        // You may choose a different machine type based on your requirements
        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
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Step 3: Deploy the postgresql-persistent Helm chart to the GKE cluster
const postgresqlChart = new k8s.helm.v3.Chart("postgresql-persistent", {
    chart: "postgresql",
    version: "10.3.11", // specify the chart version you need
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        // Provide required configurations for the postgresql Helm chart.
        // Refer to the Helm chart values for configurable options.
        persistence: {
            size: "10Gi", // Set the size of the persistent volume
        },
    },
}, { provider: k8sProvider });

// Export the cluster name and kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = cluster.kubeConfigRaw;
```

### Explanation:

- The `gcp.container.Cluster` resource creates a new GKE cluster named `postgresql-cluster`. The `initialNodeCount` sets how many nodes the cluster should have and `nodeConfig` specifies the configuration of those nodes.

- After the cluster is created, we are configuring the Pulumi Kubernetes provider with the `kubeConfigRaw` output from the created cluster. This enables Pulumi to deploy Kubernetes resources to this cluster.

- The `kubernetes.helm.v3.Chart` resource deploys the `postgresql` Helm chart from the Bitnami Helm repository, using version `10.3.11`. The `persistence.size` value sets the storage allocated for the PostgreSQL database.

- The `export` statements at the end of the program make the cluster name and kubeconfig available as stack outputs after deployment. You can use them to interact with your GKE cluster and deployed resources using tools such as `kubectl`.

Make sure you have the Pulumi CLI installed and configured for use with GCP, and note that running this program may incur charges in your GCP account for the resources created.

To run this program:

1. Save the code to a file named `index.ts`.
2. Ensure you're in a directory with the corresponding `Pulumi.yaml` project file.
3. Run `pulumi up` to create the resources. Follow the on-screen prompts to confirm the deployment.