Deploy the fastapi helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a FastAPI Helm chart on AWS Elastic Kubernetes Service (EKS), you'll need to create an EKS cluster, configure your Kubernetes provider to connect to this cluster, and then deploy the FastAPI application using Helm. Below is a Pulumi program written in TypeScript, that illustrates how to achieve this.

The program does the following:
1. Sets up an AWS EKS cluster using `aws.eks.Cluster` resource.
2. Configures the Kubernetes provider to connect to the newly created EKS cluster.
3. Uses `kubernetes.helm.v3.Chart` resource to deploy FastAPI from its Helm chart.

Make sure you have Pulumi installed and configured with AWS credentials. You'll also need Node.js for running the TypeScript program.

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';
import * as awsx from '@pulumi/awsx';
import * as eks from '@pulumi/eks';
import * as k8s from '@pulumi/kubernetes';

// Create an EKS cluster.
const cluster = new eks.Cluster('my-cluster', {
    instanceType: 't2.medium',
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: 'gp2',
    deployDashboard: false,
});

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

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the FastAPI application using Helm chart.
const fastapiChart = new k8s.helm.v3.Chart('fastapi-chart', {
    chart: 'fastapi',
    version: '0.1.0', // replace with the version of the chart you wish to deploy
    fetchOpts: {
        repo: 'https://helm-repo-url/' // replace with the actual repository URL for the FastAPI Helm chart
    },
}, { provider: k8sProvider });

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

Explanation:
- The `eks.Cluster` resource creates a new AWS EKS cluster with a number of EC2 instances, as specified by the `desiredCapacity`, `minSize`, and `maxSize` parameters.
    - [`aws.eks.Cluster` documentation](https://www.pulumi.com/registry/packages/aws/api-docs/eks/cluster/)
- `kubeconfig` is an output that provides the cluster's configuration details, needed to connect to your Kubernetes cluster using tools like `kubectl` or other Kubernetes clients.
- The `k8s.Provider` resource configures the Kubernetes provider to communicate with the given EKS cluster.
- The `k8s.helm.v3.Chart` resource is used to deploy FastAPI using its Helm chart.
    - [`kubernetes.helm.v3.Chart` documentation](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/)

Finally, we export `fastApiUrl`, which will be the URL for accessing the FastAPI application once it's deployed and externally accessible. This depends on the service being of type `LoadBalancer` and that it successfully provisions an external IP or hostname.

Remember to replace `'https://helm-repo-url/'` with the actual repository URL that hosts the FastAPI Helm chart and `'0.1.0'` with the version of the chart you want to deploy. If this chart is hosted on a Helm repository that requires authentication, make sure to include that in the `fetchOpts`.

To run this program:
1. Install Pulumi and set up your AWS credentials.
2. Initialize a new Pulumi project with `pulumi new`.
3. Replace the template generated `index.ts` with the code above.
4. Run `pulumi up` to deploy your infrastructure.