Deploy the spring-boot-demo helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a Spring Boot application using a Helm chart on AWS EKS, you'll need to create an EKS cluster and then use the Helm chart to deploy your application onto that cluster. We will use Pulumi's AWS and Kubernetes packages to accomplish these tasks.

Here's a step-by-step breakdown of the tasks we need to do:

1. **Create an EKS Cluster**: We'll start by setting up an Amazon Elastic Kubernetes Service (EKS) cluster, which will serve as the environment for running our Spring Boot application.

2. **Deploy the Helm Chart**: Once we have the EKS cluster up and running, we’ll deploy the `spring-boot-demo` Helm chart to the cluster. This assumes that `spring-boot-demo` is a Helm chart available in a Helm repository or on your local filesystem.

Below is the TypeScript program that completes this setup:

```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("springBootDemoCluster", {
    // Specify the desired version for the Kubernetes master
    version: "1.21",
    // Configure the instance types used for worker nodes
    instanceType: "t2.medium",
    // Specify the minimum and maximum number of worker nodes
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    // Deploy the cluster into the default VPC and subnets
    vpcId: aws.ec2.getVpc({ default: true }).then(vpc => vpc.id),
    publicSubnetIds: aws.ec2.getSubnetIds({ vpcId: aws.ec2.getVpc({ default: true }).then(vpc => vpc.id) }).then(subnets => subnets.ids),
});

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

// Create a Kubernetes provider instance using the cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the spring-boot-demo Helm chart
const springBootDemoChart = new k8s.helm.v3.Chart("spring-boot-demo", {
    chart: "spring-boot-demo",
    version: "1.0.0", // Replace with the specific chart version
    // Set up the necessary values for the Helm chart
    values: {
        // Insert necessary values for your chart
        // e.g., replicaCount: 2,
    },
    // Specify the EKS cluster's namespace where the chart should be deployed
    namespace: "default",
}, { provider: k8sProvider });

// Export the endpoint to access the deployed Spring Boot application
export const appEndpoint = pulumi.interpolate`http://${springBootDemoChart.getResourceProperty("v1/Service", "spring-boot-demo", "status").apply(status => status.loadBalancer.ingress[0].hostname)}`;

```

### Explanation

- **EKS Cluster**: We start by creating an EKS cluster using the `eks.Cluster` resource from Pulumi's EKS package. The configuration options such as `instanceType`, `desiredCapacity`, `minSize`, and `maxSize` can be adjusted based on your requirements.

- **Kubernetes Provider**: We then create a Pulumi Kubernetes provider using the kubeconfig obtained from our EKS cluster, which allows us to interact with our Kubernetes cluster.

- **Helm Chart Deployment**: Using the Pulumi Kubernetes provider, we deploy the `spring-boot-demo` Helm chart. You need to specify the chart version and any required values that your Helm chart expects.

- **Endpoint Export**: Once the service is deployed and an ingress is provisioned, we export the endpoint so you can easily access the Spring Boot application over the web.

Make sure you have Pulumi CLI installed and configured with the AWS credentials.

After setting up this program in a Pulumi project, run the following commands:

```bash
pulumi up      # To preview and deploy changes
pulumi stack output kubeconfig > kubeconfig.yaml   # To save the kubeconfig to a file
export KUBECONFIG=kubeconfig.yaml  # To set kubeconfig environment variable for kubectl
pulumi stack output appEndpoint    # To get the endpoint for the deployed app
```

The application should become accessible through the exported `appEndpoint`. Please make sure to customize the Helm chart properties (`chart`, `version`, and `values`) to match those of the actual `spring-boot-demo` Helm chart you are deploying.