Deploy the fastapi-app helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a `fastapi-app` helm chart on the Digital Ocean Kubernetes Service using Pulumi, you'll follow these steps:

1. **Provision a Digital Ocean Kubernetes Cluster**: You need a Kubernetes cluster where your fastapi-app will be deployed. Pulumi's `digitalocean.KubernetesCluster` resource will be used to create a new Kubernetes cluster.

2. **Install the Helm Chart**: After setting up the Kubernetes cluster, you'll need to deploy the `fastapi-app` helm chart. The Pulumi resource `kubernetes.helm.v3.Chart` is used to deploy Helm charts on a Kubernetes cluster.

Below is the TypeScript Pulumi program that carries out these steps. The program assumes that you have already set up and configured Pulumi with the necessary access tokens for Digital Ocean and that the `fastapi-app` helm chart is publicly available in a Helm repository.

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as digitalocean from '@pulumi/digitalocean';
import * as kubernetes from '@pulumi/kubernetes';

// Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: digitalocean.Regions.NYC1,
    version: "latest", // Specify the version or use 'latest'
    nodePool: {
        size: "s-2vcpu-2gb", // Size of the Droplets (nodes) to use
        name: "default",
        nodeCount: 2, // Number of nodes in the node pool
    },
});

// Export the cluster's kubeconfig
export const kubeconfig = cluster.kubeConfigs.apply(kc => kc[0].rawConfig);

// Setup a provider for deploying Helm charts to the new Kubernetes cluster
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the 'fastapi-app' Helm chart on the Kubernetes cluster
const fastapiAppChart = new kubernetes.helm.v3.Chart("fastapi-app", {
    chart: "fastapi-app",
    version: "1.0.0", // Replace with your desired chart version
    fetchOpts: {
        repo: "http://charts.example.com/", // Replace with the chart's Helm repository URL
    },
}, { provider: k8sProvider });

// Output the public IP to access the fastapi-app once it's deployed
export const fastapiAppPublicIp = fastapiAppChart.getResourceProperty("v1/Service", "fastapi-app-service", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This program starts by importing Pulumi's SDK for TypeScript, as well as the Digital Ocean and Kubernetes modules. It defines a new Digital Ocean Kubernetes cluster and exports the `kubeconfig` necessary to interact with the cluster programmatically.

The program then creates a Pulumi Kubernetes provider, which uses the `kubeconfig` from the newly created cluster. This provider is responsible for deploying resources to the Kubernetes cluster.

Lastly, the `fastapi-app` Helm chart is deployed using Pulumi’s `kubernetes.helm.v3.Chart` resource, specifying the chart name, version, and repository URL for the Helm chart. The Helm release is associated with the Kubernetes provider configured for the Digital Ocean cluster.

At the end of the program, it exports the public IP address for the `fastapi-app`, which is presumed to be exposed through a LoadBalancer service named `fastapi-app-service`. To get the actual public IP, you will need to inspect the service created by the Helm chart and make sure to use the correct resource reference if the name is different.

Remember to replace `"http://charts.example.com/"` with the actual Helm repository URL where your `fastapi-app` chart is located, and `"1.0.0"` with the version of the chart you wish to deploy.

After saving this program in a TypeScript file, you can deploy it using the Pulumi CLI command `pulumi up`. The command will provision the resources described in the program and output the public IP address you can use to interact with your FastAPI application.