Deploy the openapi helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the OpenAPI Helm chart on AWS Elastic Kubernetes Service (EKS), we'll follow these steps:

1. Create an EKS cluster.
2. Configure Kubeconfig to interact with your cluster.
3. Use the Pulumi Kubernetes provider to deploy the OpenAPI Helm chart using `kubernetes.helm.v3.Chart`.

Before we begin, ensure you have the following prerequisites in place:
- Pulumi CLI installed.
- AWS CLI configured with the necessary permissions to create EKS clusters and manage related resources.
- Helm CLI installed, if you need to customize the Helm chart values or inspect charts.
- kubectl installed, for interacting with the EKS cluster.

We'll use two important Pulumi packages:
- `@pulumi/aws`: Provides the AWS resources to create an EKS cluster.
- `@pulumi/kubernetes`: Allows us to deploy Helm charts to our EKS cluster.

Here's the complete program to deploy the OpenAPI Helm chart on AWS EKS using Pulumi:

```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("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 cluster from above.
const provider = new k8s.Provider("provider", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy the OpenAPI Helm chart using the Kubernetes provider.
const openapiChart = new k8s.helm.v3.Chart("openapi-chart", {
    chart: "openapi", // Ensure the chart name matches the one you intend to deploy
    version: "1.2.3", // Replace with the desired chart version
    namespace: "default", // Optional: specify the namespace to deploy into
    // values: {}, // Optional: override default values from the Chart
}, { provider });

// Export the base URL of the OpenAPI service once it is provisioned.
export const openapiServiceUrl = cluster.getKubeconfig().apply((kc) => {
    const kcObj = JSON.parse(kc);
    return `https://${kcObj["clusters"][0]["cluster"]["server"]}`;
});

```

### Explanation
- We start by importing the required Pulumi packages.
- We create an EKS cluster with the desired configuration, like instance type and capacity.
- Next, we export the kubeconfig of the cluster which will be used to interact with the Kubernetes cluster.
- We create a Kubernetes provider to manage our Kubernetes resources using the kubeconfig from the EKS cluster.
- We deploy the Helm chart for OpenAPI onto the EKS cluster by specifying its name and version. If the values aren't defined, the defaults of the chart are used.
- Finally, we export the OpenAPI service URL which can be used to access the deployed service.

The above program is a basic configuration for deploying a Helm chart on an EKS cluster. In a real-world scenario, you might have additional configurations for the EKS cluster or Helm chart, such as node groups, scaling configurations, or custom values for the Helm release.

Once this program is in a `.ts` file, you can deploy it using the following Pulumi CLI commands:

```sh
pulumi stack init dev  # Initialize a new stack if you don't have one
pulumi up              # Deploy the Pulumi program
```

This will provision the resources defined in the program. The `pulumi up` command will show you a preview of the resources that will be created and prompt for confirmation before proceeding with the deployment.