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

Question

Pulumi · Accepted Answer

To deploy the `python-fastapi-postgres` Helm chart on Oracle Kubernetes Engine (OKE), we will use the following Pulumi resources:

1. `oci.ContainerEngine.Cluster`: This resource will provision an OKE cluster where our application will reside.
2. `kubernetes.helm.sh/v3.Chart`: This represents a Helm chart for a set of Kubernetes resources, in this case, `python-fastapi-postgres`.

The process involves creating an OKE cluster and then deploying the Helm chart to that cluster.

Below is a TypeScript program that defines the necessary Pulumi resources to accomplish this task. The actual deployment of the Helm chart to the OKE cluster will occur during the Pulumi up operation, which requires OCI credentials configured in your environment.

Make sure you have the Pulumi CLI installed and you are logged in to your OCI account.

Here's the program:

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

// Define your compartment ID where the OKE cluster should be provisioned
const compartmentId = "your-oci-compartment-id";

// Create an OKE cluster
const cluster = new oci.containerengine.Cluster("myOkeCluster", {
    compartmentId: compartmentId,
    vcnId: "oci-vcn-id", // Ensure you have a VCN ID to reference
    kubernetesVersion: "v1.21.4", // Use a version compatible with your requirements
    options: {
        admissionControllerOptions: {
            isPodSecurityPolicyEnabled: true,
        },
        // Define other options as needed for your specific use case
    },
});

// Once your cluster is created, you need to configure Kubernetes providers to point to the OKE cluster.
// For this, you will need to retrieve the kubeconfig file from OCI.

// For brevity, we're passing empty kubeconfig - in a real scenario, you would fetch and use an actual kubeconfig
const k8sProvider = new k8s.Provider("myK8sProvider", {
    kubeconfig: "",
});

// Deploy the python-fastapi-postgres Helm chart to the OKE cluster
const chart = new k8s.helm.v3.Chart("myPythonFastApiPostgresChart", {
    chart: "python-fastapi-postgres",
    // Specify the repository if it's from a custom Helm chart repository
    // or properly reference if it's stored in one of the known repositories
    version: "chart-version", // replace with the actual chart version
    namespace: "default", // specify the namespace if needed
}, { provider: k8sProvider });

// Export the cluster’s endpoint and kubeconfig in order for us to interact with the cluster
export const kubeconfig = cluster.kubeconfig;
export const clusterEndpoint = cluster.endpoints.apply(e => e.publicEndpoint);

```

**Note about `kubeconfig`:** The above code assumes an already created and configured Kubernetes cluster with required networking and permissions set up in OCI. The `kubeconfig` variable in the `k8s.Provider` instantiation is currently set as an empty string for brevity. In a real-world scenario, you need to use the OCI CLI or SDK to generate the kubeconfig for your OKE cluster. The generated kubeconfig will have details on how to connect to the Kubernetes API server.

**Before running the program**, ensure that you fill in the appropriate details such as your compartment ID, VCN ID, the version of Kubernetes you want to use, and the version of the Helm chart you're deploying.

To execute the program, run the following commands:

1. Initialize a new Pulumi stack, which is an isolated environment for your project:

```shell
   pulumi stack init dev
   ```

2. Set the required OCI configuration for Pulumi:

```shell
   pulumi config set oci:compartmentId your-oci-compartment-id
   ```

3. Install dependencies:

```shell
   npm install
   ```

4. Run `pulumi up` to create the resources. Pulumi will print out the proposed changes before making them:

```shell
   pulumi up
   ```

After running `pulumi up`, your OKE cluster and Helm chart deployment should be provisioned as specified.