Deploy the spring-boot-rest-http helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `spring-boot-rest-http` Helm chart on an AWS EKS cluster using Pulumi, you will need to perform a few high-level steps:

1. **Create an EKS Cluster**: Set up an Elastic Kubernetes Service (EKS) cluster in AWS. This is where your application will run.
2. **Deploy a Helm Chart**: Once you have the EKS cluster, you can use Pulumi's Kubernetes provider to deploy the `spring-boot-rest-http` Helm chart to the cluster.

### 1. Create an EKS Cluster

To create an EKS cluster, you'll use the `eks.Cluster` resource from the EKS Pulumi package. This high-level component simplifies the creation of an EKS cluster.

- The `eks.Cluster` creates the necessary AWS resources, like the EKS control plane, worker nodes, and required IAM roles and policies.
- You can customize your cluster by specifying properties like node instance types, the desired number of nodes, and Kubernetes version.

### 2. Deploy a Helm Chart

After the cluster is created, you'll deploy the `spring-boot-rest-http` Helm chart. Pulumi's Helm Chart resource from the Kubernetes package allows you to deploy existing Helm charts into your cluster.

- You need to specify the name of the chart, the version (if needed), and any additional values you want to override in the Helm chart.

Below is a Pulumi program in TypeScript to accomplish these steps:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster("my-cluster", {
    // Specify the number of worker nodes
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,

// Specify the instance type for the worker nodes
    instanceType: "t2.medium",

// Specifying the Kubernetes version is optional; if omitted, EKS will use the default version.
    version: "1.21",
});

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

// Step 2: Deploy the `spring-boot-rest-http` Helm chart to the EKS cluster.
const helmChart = new k8s.helm.v3.Chart("my-spring-boot-rest-http", {
    repo: "my-helm-repo", // Replace with the actual repository containing your chart
    chart: "spring-boot-rest-http",
    // Specify the chart version to deploy, if necessary
    version: "1.0.0",
    // If needed, provide custom values to the chart
    values: {
        service: {
            type: "LoadBalancer",
        },
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeconfig }) });

// Export the Helm chart deployment result
export const chartName = helmChart.name;
```

### Explanation

- **EKS Cluster**: The `eks.Cluster` resource creates a new EKS cluster with the specified number of nodes, instance types, and Kubernetes version.
- **Exported `kubeconfig`**: This line exports the `kubeconfig` needed to interact with your cluster using `kubectl` or other Kubernetes tools.
- **Helm Chart**: The `k8s.helm.v3.Chart` resource is used to deploy the `spring-boot-rest-http` Helm chart into the EKS cluster.
- **Chart Repository**: Replace `"my-helm-repo"` with the actual Helm chart repository containing the `spring-boot-rest-http` chart.
- **Custom Values**: The `values` property is a place where you can override default chart values. Here it is setting the `service.type` to `"LoadBalancer"` which will provision an AWS Load Balancer for your application.
- **K8s Provider**: The new `k8s.Provider` construct tells Pulumi to use the kubeconfig from the newly created EKS cluster.

Once you have the above code in a `.ts` file and installed the necessary packages, you can run it with Pulumi CLI to provision the resources. After provisioning, the `spring-boot-rest-http` application should be running on the EKS cluster and accessible via the AWS Load Balancer.