Deploy the gorse helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Gorse Helm chart on AWS EKS using Pulumi, we will first need to set up an Amazon EKS cluster, and then we will deploy the Gorse Helm chart onto that cluster.

### Creating the EKS Cluster

We'll start by creating a new EKS cluster using the `eks.Cluster` resource. This resource wraps the entire creation and configuration process of an EKS cluster which includes creating the VPC, subnets, and the node group.

### Deploying the Gorse Helm Chart

After the cluster is set up, we will deploy the Gorse Helm chart onto our EKS cluster using the `kubernetes.helm.v3.Chart` resource. This resource allows us to deploy Helm charts into a Kubernetes cluster managed by Pulumi.

Here's the TypeScript code that accomplishes these steps. This program assumes that you have AWS credentials configured for Pulumi to use.

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

// Create an EKS cluster with the default settings.
// This will automatically create a VPC and deploy a managed node group.
const cluster = new eks.Cluster("my-cluster", {
  desiredCapacity: 2, // Desired number of worker nodes
  minSize: 1,        // Minimum number of worker nodes
  maxSize: 3,        // Maximum number of worker nodes
});

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

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

// Deploy the Gorse Helm chart to the EKS cluster.
const gorseChart = new k8s.helm.v3.Chart("gorse", {
  chart: "gorse",
  version: "0.1.0", // Use the specific chart version you need
  fetchOpts: {
    repo: "https://helm.gorse.io", // Replace with the correct Helm chart repository
  },
}, { provider: k8sProvider });

// Export the Helm chart deployment metadata.
export const gorseChartResources = gorseChart.resources;
```

Here is the detailed explanation of each step in the code:

1. **EKS Cluster Creation**: We create an Amazon EKS cluster named `"my-cluster"` with the `eks.Cluster` resource. The `desiredCapacity`, `minSize`, and `maxSize` arguments define the scaling properties of our node group, which is a set of worker nodes.

2. **Kubeconfig Export**: We export the `kubeconfig` of our EKS cluster, which is a configuration file that contains the information needed to connect to the cluster with the `kubectl` command-line tool or any Kubernetes client.

3. **Kubernetes Provider**: To interact with our newly created EKS cluster, we need to establish a provider that points to the specific instance of Kubernetes. We pass the `kubeconfig` of our cluster to the `k8s.Provider`.

4. **Helm Chart Deployment**: Finally, we deploy the Gorse Helm chart into our EKS cluster. We specify the chart name, version, and the repository from which to fetch the chart. Note that `"gorse"` and `"0.1.0"` represent the name and version of the Gorse Helm chart you wish to deploy. You'll need to replace `"https://helm.gorse.io"` with the correct repository URL for the Gorse Helm chart.

5. **Helm Chart Resources Export**: At the end, we export the resources created as a result of deploying the Helm chart. This is useful for tracking the resources that were created in your Kubernetes cluster as part of the Helm chart deployment.

Remember to replace the placeholders for the Helm chart version, and the Helm repository URL with the correct values for the Gorse Helm chart.

To use this program, you would typically save the code to a file (e.g. `index.ts`), and then you can deploy it by running `pulumi up` from the command line in the same directory as your file. Pulumi will handle the creation of all resources specified by this program.