Deploy the pocketbase-helm helm chart on AWS EKS

Question

Pulumi · Accepted Answer

Deploying a Helm chart on AWS EKS involves several steps. We will use Pulumi to create an EKS cluster and then deploy the Pocketbase Helm chart onto it. Here's an overview of what we are going to do:

1. Create an EKS cluster: We will set up an Amazon EKS cluster, which is a managed Kubernetes service that makes it easy to run Kubernetes on AWS without needing to install and operate your own Kubernetes control plane.

2. Deploy Pocketbase Helm chart: Once we have our EKS cluster set up, we will deploy Pocketbase, which is assumed to be available as a Helm chart. Helm is a package manager for Kubernetes that allows you to manage Kubernetes applications.

Before we start, ensure that you have the Pulumi CLI installed, AWS CLI configured with your credentials, and that you are authenticated to an AWS account. Also, make sure you have `kubectl` and `helm` CLI tools installed to interact with the Kubernetes cluster and manage Helm charts.

Now, let's get started with the Pulumi program in TypeScript:

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

// Create an EKS cluster.
const cluster = new eks.Cluster("my-eks-cluster", {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
});

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

// Use the kubeconfig to create a Kubernetes provider instance.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the Pocketbase Helm chart using the Kubernetes provider.
const pocketbaseChart = new k8s.helm.v3.Chart("pocketbase", {
    chart: "pocketbase-helm",
    fetchOpts: {
        repo: "https://charts.pocketbase.io",
    },
}, { provider });

// Export the Pocketbase service endpoint.
export const pocketbaseService = pocketbaseChart.getResource("v1/Service", "pocketbase", "pocketbase-service").status.apply(status => {
    return status.loadBalancer.ingress[0].hostname;
});
```

### Explanation:

- `eks.Cluster`: This is used to create a managed EKS cluster. The `desiredCapacity`, `minSize`, and `maxSize` parameters define the autoscaling properties for our node group. You can adjust these numbers based on your needs.

- `kubeconfig`: We declare a Pulumi export to output the kubeconfig file, which will allow you to use `kubectl` to interact with your EKS cluster.

- `k8s.Provider`: This Pulumi Kubernetes provider uses the kubeconfig of the EKS cluster. This allows Pulumi to deploy resources onto the EKS cluster.

- `k8s.helm.v3.Chart`: We use this to deploy the Pocketbase Helm chart into our EKS cluster. Here we assume that the Helm chart `pocketbase-helm` is located in the provided `repo` URL.

- The `pocketbaseService` is an export that will output the load balancer's hostname where the Pocketbase service is accessible.

Remember that you might need to add the Pocketbase Helm repository to your Helm CLI manually using `helm repo add` if you plan to use Helm CLI directly at any point.

If "pocketbase-helm" is not the correct name or if it is not located at `https://charts.pocketbase.io`, you will need to adjust the `repo` and `chart` fields accordingly.

Finally, run `pulumi up` to create the resources in your AWS account. After Pulumi finishes deploying the Helm chart, you can view the Pocketbase service endpoint from the Pulumi stack's outputs.