Deploy the postgres-observability helm chart on Rancher

Question

Pulumi · Accepted Answer

To deploy the `postgres-observability` Helm chart on Rancher, you'll need to follow these steps:

1. **Setting Up**: Ensure you have Pulumi installed, a Pulumi account set up, and the Rancher2 provider configured in Pulumi.

2. **Initialization**: Start by creating a new Pulumi project and stack. You need to choose a project name, runtime (`typescript`), and cloud (`Rancher2`).

3. **Writing the Code**: Write a Pulumi program in TypeScript that uses the Rancher2 provider to deploy the `postgres-observability` Helm chart.

4. **Running the Program**: Use Pulumi command-line tools to deploy your infrastructure by running `pulumi up`.

5. **Monitoring Deployment**: Check the status of your deployment and observe the resources created.

Below is a detailed TypeScript Pulumi program to accomplish this:

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

// Step 1:
// Replace `rancherClusterId` with the appropriate Rancher Cluster ID where you want to deploy the Helm chart.
const rancherClusterId = "your-rancher-cluster-id";

// Step 2:
// Create a Rancher project dedicated to the PostgreSQL observability deployment.
const observabilityProject = new rancher2.Project("postgres-observability-project", {
    clusterId: rancherClusterId,
    name: "PostgresObservability",
    description: "A project to host Postgres observability tools",
});

// Step 3:
// Create a Kubernetes provider that targets the Rancher Kubernetes cluster.
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: observabilityProject.kubeconfig.apply(kubeconfig => kubeconfig),
});

// Step 4:
// Deploy the postgres-observability Helm chart.
// Note: You must replace `chartVersion`, `helmRepoUrl`, and `helmChartName` with correct values for the postgres-observability chart.
const chartVersion = "x.y.z";                  // Replace with the actual chart version
const helmRepoUrl = "http://helm-repo.url";    // Replace with the Helm repository URL
const helmChartName = "postgres-observability";// Replace with the correct Helm chart name

const postgresObservabilityChart = new k8s.helm.v3.Chart("postgres-observability", {
    chart: helmChartName,
    version: chartVersion,
    fetchOpts: {
        repo: helmRepoUrl,
    },
}, { provider: k8sProvider });

// Step 5:
// Export any necessary resources that can be used to access the deployed chart.
export const projectDisplayName = observabilityProject.defaultProjectQuota.apply(quota => quota.projectLimit["display-name"]);
export const kubeconfig = observabilityProject.kubeconfig;

// You can run this Pulumi program by running `pulumi up` in your CLI.
// The command will show you a preview of the resources that will be deployed.
// If everything looks correct, you can proceed to confirm the deployment.
```

**Explanation**:

1. We import the necessary Pulumi packages: `rancher2` for interacting with Rancher, `kubernetes` to handle Kubernetes resources, and `pulumi` core for configurations.

2. We create a Rancher project where our Helm chart will be deployed using `rancher2.Project`.

3. We use the `k8s.Provider` to tell Pulumi to target our newly created Rancher Kubernetes cluster by passing the kubeconfig from the `observabilityProject`.

4. We declare a Helm chart resource using `k8s.helm.v3.Chart`, which will install the `postgres-observability` Helm chart in the Rancher cluster. The exact version and repository of the chart need to be specified.

5. We export the display name