Deploy the baget helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the BaGet Helm chart on AWS Elastic Kubernetes Service (EKS), we need to carry out several steps:

1. **Provision the EKS Cluster**: We'll use the `eks.Cluster` resource from the `eks` Pulumi package, which simplifies the task of creating an EKS cluster by abstracting away the complexity that comes with setting up an EKS cluster from scratch.

2. **Install Helm and Deploy the Chart**: After setting up an EKS cluster, we need to install Helm and deploy the BaGet chart to the cluster. This usually involves the `helm.v3.Chart` resource of Pulumi, which allows us to deploy Helm charts.

Here's a detailed Pulumi program written in TypeScript that follows the above steps:

Firstly, make sure to install the required Pulumi NPM packages by running:

```bash
npm install @pulumi/eks @pulumi/kubernetes
```

Here's 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 kubernetes 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 EKS cluster.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the BaGet Helm chart to the EKS cluster.
const bagetChart = new kubernetes.helm.v3.Chart("baget", {
    repo: "loic-sharma", // Specify the Helm repo name here
    chart: "baget",
    version: "0.1.0", // Put the version of the Helm chart you want to deploy
    namespace: "default", // Define the namespace where the chart will be installed
}, { provider: k8sProvider });

// Export the Baget service endpoint, if it's exposed as a LoadBalancer service.
export const bagetEndpoint = bagetChart.getResourceProperty("v1/Service", "baget", "status").apply(status => {
    const ingresses = status.loadBalancer.ingress;
    if (!ingresses || ingresses.length === 0) {
        pulumi.log.warn("Baget service does not have an external endpoint yet.");
        return "not-available";
    }
    const ingress = ingresses[0];
    if (ingress.ip) return `http://${ingress.ip}`;
    if (ingress.hostname) return `http://${ingress.hostname}`;
    return "not-available";
});
```

Here's what each section of the code does:

- We initialize a new EKS cluster with `eks.Cluster`, specifying an instance type and the desired scale of our cluster.

- We export the `kubeconfig`, which contains the necessary configuration to connect to our EKS cluster with `kubectl` or any Kubernetes client.

- Then we create a Kubernetes provider that points to our newly created EKS cluster. This allows Pulumi to target this cluster when creating other Kubernetes resources.

- We deploy the BaGet Helm chart using `kubernetes.helm.v3.Chart`. We specify the Helm chart repository and the version of the chart we want to deploy. Replace `"loic-sharma"` with the actual name of the Helm repository where the BaGet chart is hosted.

- Finally, we attempt to extract the load balancer's endpoint, assuming that the BaGet chart exposes a service of type LoadBalancer. The endpoint will be exported, which gives you a URL where you can access the deployed BaGet service.

Remember to replace the placeholder values like `repo`, `chart`, and `version` with actual values appropriate for the BaGet Helm chart you intend to use.

To run this program, save it in a file `index.ts`, and execute the following Pulumi CLI commands:

```bash
pulumi up
```

This command will prompt you to confirm the actions proposed before making any changes to your cloud resources. Make sure to review the changes and then approve them to start the deployment process. After deployment, Pulumi will output the created resources' IDs and any exported endpoints or other useful information.