Deploy the sp-boot-doc-helm helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `sp-boot-doc-helm` Helm chart on AWS Elastic Kubernetes Service (EKS), you'll need to set up an EKS cluster, configure your Kubernetes provider to communicate with the cluster, and deploy the chart using the Helm resource.

I'll guide you through a Pulumi program written in TypeScript that performs these tasks. We will utilize the `@pulumi/eks` package to create the EKS cluster, which is a high-level package specifically designed to simplify EKS cluster creation with Pulumi.

First, we'll install the necessary Pulumi packages. You can do this by running:

```sh
npm install @pulumi/pulumi @pulumi/aws @pulumi/eks @pulumi/kubernetes
```

Below is the program that deploys an EKS cluster and installs the `sp-boot-doc-helm` helm chart. Follow the comments which explain each part of the code:

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

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

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

// Set up the Helm chart for 'sp-boot-doc-helm'. You must obtain the correct repository URL and chart name.
const chart = new k8s.helm.v3.Chart("sp-boot-doc-helm-chart", {
    chart: "sp-boot-doc-helm",
    // Assuming 'repoURL' points to the location where the chart is hosted.
    fetchOpts: {
        repo: "https://charts.example.com/",
    },
    // Specify the version if necessary.
    version: "1.0.0",
    values: {
        // Provide any configuration specifics to the chart.
        service: {
            type: "LoadBalancer",
        },
    },
    // Ensure that helm uses the EKS cluster we created above.
    }, {
    provider: new k8s.Provider("k8s-provider", {
        kubeconfig: cluster.kubeconfig,
    }),
});

// Export the Helm chart resources.
export const helmResources = chart.resources;
```

Here's a step-by-step explanation of the program:

1. Import the `@pulumi/pulumi`, `@pulumi/eks`, and `@pulumi/kubernetes` packages.
2. Create the EKS cluster, assigning variables for the instance type, desired capacity (i.e., the number of nodes), and the minimum and maximum size of the scaling group.
3. Export the generated `kubeconfig`, which you'll need to interact with the Kubernetes cluster.
4. Set up the 'sp-boot-doc-helm' Helm chart. You must specify the correct repository URL where the Helm chart is hosted.
5. The `values` object is used to provide configuration values that override the defaults in the Helm chart.
6. The `k8s.Provider` resource is instantiated with the `kubeconfig` from the EKS cluster, ensuring that the Helm chart is deployed to the newly created EKS cluster.
7. Export the Helm chart's resources for easy access and inspection.

Make sure you have configured your AWS credentials before running this Pulumi program. The program can be executed using the Pulumi CLI to create the infrastructure defined by the code.

Please replace `"https://charts.example.com/"` with the correct Helm chart repository URL and `sp-boot-doc-helm` with the correct chart name and version if it's different from `"1.0.0"`.