Deploy the postgres-cluster helm chart on Rancher

Question

Pulumi · Accepted Answer

In order to deploy a Helm chart for a PostgreSQL cluster on a Rancher-managed Kubernetes cluster using Pulumi, you will need to have Rancher set up with a Kubernetes cluster already provisioned. This cluster can be an RKE (Rancher Kubernetes Engine), EKS (Amazon Elastic Kubernetes Service), AKS (Azure Kubernetes Service), GKE (Google Kubernetes Engine), or any Kubernetes cluster registered with Rancher.

Pulumi provides a Helm Release resource as part of its Kubernetes provider, which can be used to deploy Helm charts. However, to interact with Rancher specifically, Pulumi offers a Rancher2 provider that allows you to manage Rancher resources.

Below is a TypeScript program that demonstrates how to deploy the `postgres-cluster` Helm chart on a Rancher-managed Kubernetes cluster. This program assumes that you have already configured your Pulumi environment with access to the Rancher2 API.

First, we will start by importing the necessary Pulumi packages for Rancher2 and Kubernetes. Then we will define a Kubernetes provider to interact with the Kubernetes cluster managed by Rancher. After setting up the provider, we'll deploy the `postgres-cluster` Helm chart using the `helm.v3.Chart` resource.

Here's what the Pulumi program looks like:

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

// Create a new Rancher2 provider
const rancher2Provider = new rancher2.Provider("rancher2Provider", {
    // Specify Rancher API URL and credentials
    apiUrl: "https://your-rancher-api-url",
    accessKey: "your-rancher-access-key",
    secretKey: "your-rancher-secret-key",
});

// Create a reference to the target Rancher-managed Kubernetes cluster
const cluster = rancher2.Cluster.get("my-cluster", "the-cluster-id", { provider: rancher2Provider });

// Set up the Kubernetes provider using credentials from the Rancher cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfig,
    // Optionally, specify the context if needed
    // context: "desired-context-name",
});

// Deploy the postgres-cluster Helm chart on the cluster
const postgresClusterChart = new k8s.helm.v3.Chart("postgres-cluster", {
    chart: "postgresql",
    version: "a-specific-chart-version", // specify the exact chart version you want to deploy
    namespace: "default", // target Kubernetes namespace
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami", // replace with the Helm chart repository containing postgres-cluster
    },
    // Specify values for the PostgreSQL Helm chart
    values: { 
        // Replace these with actual PostgreSQL values
        postgresqlUsername: "postgres-user",
        postgresqlPassword: "postgres-pass",
        postgresqlDatabase: "postgres-db",
    },
}, { provider: k8sProvider });

// Export the endpoint to access PostgreSQL
export const postgresqlEndpoint = postgresClusterChart.getResourceProperty("v1/Service", "postgres-cluster-postgresql", "status").apply(status => {
    return status.loadBalancer.ingress[0].ip;
});
```

Explanation:

1. We define a `rancher2.Provider` that enables us to interact with the Rancher API. Replace `your-rancher-api-url`, `your-rancher-access-key`, and `your-rancher-secret-key` with your actual Rancher API endpoint and credentials.
   
2. We obtain a reference to the Kubernetes cluster in Rancher that you wish to deploy to, providing the cluster ID and the Rancher provider configuration.

3. A `k8s.Provider` is created using the `kubeconfig` obtained from the Rancher cluster, which allows Pulumi to interact with the Kubernetes cluster.

4. Using the `k8s.helm.v3.Chart` resource, we deploy the `postgres-cluster` Helm chart (in this case `postgresql`, you should replace this with the actual name of the chart if different). You'll need to provide the specific Helm chart details such as `version`, `repo`, and `values`.

5. The `values` object should be replaced with the specific configuration values required for the PostgreSQL cluster Helm chart you are using.

6. Finally, we export the `postgresqlEndpoint`, which is the load balancer ingress IP address for the deployed PostgreSQL service. This value can be used to connect to PostgreSQL after deployment.

Remember to replace placeholders (like the repository URL, chart version, chart values, etc.) with actual information that corresponds to your specific use case and the Helm chart requirements.

Please make sure that your Pulumi stack and Rancher environment are appropriately configured before running this program. You can run the program using the `pulumi up` command once you've replaced placeholders with actual values.