Deploy the fastapi helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy a FastAPI application using a Helm chart on the Oracle Kubernetes Engine (OKE), we will primarily use the `kubernetes.helm.sh/v3.Chart` resource from Pulumi's Kubernetes provider. This resource allows us to deploy Helm charts on a Kubernetes cluster.

Here's a step-by-step process, followed by the code:

1. **Prerequisites**: We must have the Oracle Kubernetes Engine (OKE) cluster up and running. The Kubernetes context should be pointing to your OKE cluster, and you should have configured your Pulumi for the Kubernetes provider.

2. **Pulumi Kubernetes Provider**: This provider allows us to interact with Kubernetes resources. It's assumed that you have already set up your OKE cluster, and your `kubeconfig` file is pointing to it. Pulumi will use this configuration to interact with your Kubernetes cluster.

3. **Helm Chart for FastAPI**: Helm charts help define, install, and upgrade even the most complex Kubernetes application. In this case, we will look for a public Helm chart for a FastAPI application or use a generic chart that allows us to deploy a FastAPI container.

4. **Deployment**: We will create a Pulumi program that uses the `kubernetes.helm.sh/v3.Chart` resource to deploy a FastAPI application to your OKE cluster.

Below is the TypeScript program that deploys a FastAPI Helm chart to an OKE cluster:

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

// Define a Helm chart resource that installs/deploy the FastAPI application.
const fastapiChart = new kubernetes.helm.v3.Chart("fastapi-helm-chart", {
    // Use the official Helm chart for FastAPI if available or adapt the settings
    // for a Helm chart that runs a FastAPI container.
    chart: "fastapi", // Replace with actual chart reference if official one exists
    version: "1.0.0", // Replace with the actual chart version
    // In case FastAPI doesn't have an official Helm chart, we can use a generic
    // one like `bitnami/common` and pass appropriate parameters to it.
    // This usually includes configuring the container image, ports, etc.
    fetchOpts:{
        repo: "https://helm-repo-url/", // Replace with the actual Helm repository URL
    },
    // Values to pass to the Helm chart, which will configure the FastAPI container.
    values: {
        image: {
            repository: "tiangolo/uvicorn-gunicorn-fastapi", // FastAPI Docker image
            tag: "latest", // Image tag to use
        },
        service: {
            type: "ClusterIP", // Expose the service internally within the cluster
            port: 80, // Port where FastAPI is exposed
        },
    },
});

// Export the public URL for the FastAPI service.
export const fastapiServiceUrl = fastapiChart.getResourceProperty("v1/Service", "fastapi-helm-chart-fastapi", "status").apply(status => `http://${status.loadBalancer.ingress[0].ip}:${status.loadBalancer.ports[0].port}`);

```

**Explanation of the Program**:
- We import the Kubernetes package from Pulumi, which provides the necessary classes and functions to work with Kubernetes resources.
- We define a `Chart` resource representing our FastAPI application.
- We specify the chart's name and version. Since FastAPI doesn't have an official Helm chart, we would use a generic one, specifying the container image and other settings accordingly.
- We use `.getResourceProperty` to obtain the public URL of the deployed service. This URL assumes the service is exposed through a `LoadBalancer`. If you're using a `ClusterIP` service as we specified in the values, you'll access FastAPI internally within the cluster.

Please note that an actual image URL, chart name, version, and Helm repo URL need to be specified as per availability. The `tiangolo/uvicorn-gunicorn-fastapi` is a popular Docker image for FastAPI applications, and in this program it is used as a placeholder.

To run this Pulumi program:

1. Install Pulumi CLI and configure it.
2. Install Node.js and npm on your machine to work with Pulumi's TypeScript SDK.
3. Create a new directory for your Pulumi project and initialize it with `pulumi new kubernetes-typescript`.
4. Replace the content of `index.ts` with the code provided above.
5. Run `pulumi up` to execute the code and deploy the FastAPI application to your OKE cluster.