Deploy the python-fastapi-postgres helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy a Python FastAPI application with a PostgreSQL database using a Helm chart on Azure Managed OpenShift, you will need to achieve the following steps:

Set up an Azure Managed OpenShift Cluster: You'll first need to create an Azure Red Hat OpenShift cluster where your application and database will run.
Deploy the python-fastapi-postgres Helm Chart: Once the cluster is in place, you'll deploy your Python FastAPI application with PostgreSQL using a Helm chart, which is a pre-packaged set of resources that can be deployed on Kubernetes.

We will use Pulumi's Azure Native package (azure-native) to create the OpenShift Managed Cluster. Then, we'll use the Kubernetes provider (kubernetes) to deploy the Helm chart onto the cluster.

Below is a TypeScript Pulumi program that demonstrates these steps.

import * as pulumi from "@pulumi/pulumi";
import * as azureNative from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";
import * as azuread from "@pulumi/azuread";

// Step 1: Set up the Azure Managed OpenShift cluster.
const resourceGroup = new azureNative.resources.ResourceGroup("myResourceGroup");

const adApp = new azuread.Application("aksApplication", {
    displayName: "aksApplication",
});

const adSp = new azuread.ServicePrincipal("aksSp", {
    applicationId: adApp.applicationId,
});

const adSpPassword = new azuread.ServicePrincipalPassword("aksspPassword", {
    servicePrincipalId: adSp.id,
    value: "<password>", // Replace with a suitable password.
    endDate: "2099-01-01T00:00:00Z",
});

// Replace the following values with your specific cluster configurations.
const cluster = new azureNative.redhatopenshift.OpenShiftCluster("myOpenShiftCluster", {
    resourceGroupName: resourceGroup.name,
    resourceName: "myOpenShiftCluster",
    location: resourceGroup.location,
    openShiftVersion: "4.3", // Specify your desired OpenShift version.
    tags: {
        environment: "production",
    },
    clusterProfile: {
        domain: "example.com", // Replace with your domain name.
        pullSecret: "<pullSecret>", // Your OpenShift pull secret.
    },
    networkProfile: {
        podCidr: "10.0.0.0/16",
        serviceCidr: "172.30.0.0/16",
    },
    masterProfile: {
        name: "master",
        vmSize: "Standard_D8s_v3",
        subnetId: "", // Provide the subnet ID for the master nodes.
    },
    workerProfiles: [
        {
            name: "worker",
            count: 3,
            vmSize: "Standard_D4s_v3",
            subnetId: "", // Provide the subnet ID for the worker nodes.
        },
    ],
    apiserverProfile: {
        visibility: "Private",
    },
    ingressProfiles: [
        {
            name: "default",
            visibility: "Public",
        },
    ],
    servicePrincipalProfile: {
        clientId: adApp.applicationId,
        clientSecret: adSpPassword.value,
    },
});

// Step 2: Deploy the python-fastapi-postgres Helm chart.
// First, we need to set up a K8s provider pointing to the newly created OpenShift cluster.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Now use the k8s provider to deploy the Helm chart.
const chart = new k8s.helm.v3.Chart("fastapi-postgres-chart", {
    chart: "python-fastapi-postgres", // The name of the chart.
    version: "1.0.0", // Specify the chart version.
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the actual Helm chart repository URL.
    },
    values: {
        // Specify any values that you want to override in the Helm chart.
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig.
export const kubeConfig = cluster.kubeConfigRaw;

In the above program, replace the comments and placeholders like <password>, <pullSecret>, and the chart repo URL with the actual values you want to use.

To run this Pulumi program, save it to a file with a .ts extension, navigate to the directory where you saved the file, and run pulumi up. Before you run pulumi up, make sure you have authenticated with Azure using az login and set up the appropriate Pulumi stack with pulumi stack init.

Please note that deploying an OpenShift cluster could take some time. After the cluster is provisioned, Pulumi will deploy the selected Helm chart into the newly created OpenShift cluster.