Deploy the aws-rds-postgresql-database helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the AWS RDS PostgreSQL database Helm chart on Azure Managed OpenShift Service, we'll need to perform several actions:

1. Provision an Azure Red Hat OpenShift Cluster using Pulumi's Azure Native provider.
2. Once the cluster is ready, configure `kubectl` to interact with the OpenShift cluster.
3. Use Pulumi's Kubernetes provider to deploy the PostgreSQL Helm chart in the OpenShift cluster.

Below, you'll find a detailed Pulumi TypeScript program that carries out these steps. Before running this code, you need to make sure you have Pulumi installed and are authenticated with Azure and have the necessary permissions to create resources.

First, you will need the `@pulumi/azure-native` and `@pulumi/kubernetes` packages. You can install these using:

```bash
npm install @pulumi/azure-native @pulumi/kubernetes
```

Now, let's go through the program:

```typescript
import * as azure from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";
import * as pulumi from "@pulumi/pulumi";

// Step 1: Provision your Azure Red Hat OpenShift Cluster
const resourceGroupName = new azure.resources.ResourceGroup({
    resourceGroupName: "openshift-resource-group",
}).name;

const openShiftCluster = new azure.redhatopenshift.OpenShiftCluster("myOpenShiftCluster", {
    resourceGroupName: resourceGroupName,
    resourceName: "myOpenShiftCluster",
    location: "eastus", // Choose the Azure region which supports Azure Red Hat OpenShift
    clusterProfile: {
        domain: "example", // Replace with your domain
        version: "4.3.0", // Specify your desired OpenShift version
    },
    masterProfile: {
        vmSize: "Standard_D8s_v3",
    },
    networkProfile: {
        vnetCidr: "10.0.0.0/22",
    },
    tags: {
        environment: "Production",
    },
});

// Step 2: Set up kubectl for the newly created OpenShift Cluster
const creds = pulumi.all([resourceGroupName, openShiftCluster.name]).apply(([rg, name]) =>
    azure.redhatopenshift.listOpenShiftClusterAdminCredentials({
        resourceGroupName: rg,
        resourceName: name,
    }),
);

// Importing the kubeconfig
const kubeConfig = creds.apply(c => c.kubeconfigs[0].value);

// Create a kubernetes provider instance that uses the obtained kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeConfig,
});

// Step 3: Deploy the AWS RDS PostgreSQL database Helm chart
const postgresqlChart = new k8s.helm.v3.Chart("aws-rds-postgresql-database", {
    chart: "aws-rds-postgresql",
    version: "1.0.0", // Replace with the specific chart version
    fetchOpts: {
        repo: "https://your-repo-name", // Set to the Helm chart repository URL
    },
}, { provider: k8sProvider });

export const kubeconfig = kubeConfig;
export const clusterName = openShiftCluster.name;
```

In this program, we:

- Create an Azure resource group to contain our cluster.
- Use the `OpenShiftCluster` resource from the Azure Native package to create an OpenShift cluster in Azure.
- Retrieve the admin credentials for the new OpenShift cluster to set up kubectl.
- Deploy the PostgreSQL database using a Helm chart on the Kubernetes cluster managed by OpenShift.

It's important to note several details:

- You'll need to change `"example"` to your actual domain and pick the correct region that supports Azure Red Hat OpenShift in the `location` property.
- The `version` should be set to the desired OpenShift version that is available on Azure.
- The `chart` property should be set to the name of the Helm chart that you are deploying, and the `version` property to the chart version.
- The `repo` property within `fetchOpts` should be set to the repository URL containing the Helm chart for the AWS RDS PostgreSQL database.

Remember to replace placeholder text like `"https://your-repo-name"` with actual values relevant to your use case.

After you run the program using `pulumi up` command, it will provision the necessary Azure resources and deploy the PostgreSQL database through the specified Helm chart.
Make sure you are authenticated with Azure CLI and have necessary permissions and the OpenShift cluster is ready to accept deployments before running the command.