Deploy the simplified-ob-pattern-1 helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a Helm chart on AWS EKS, we need to complete several tasks:

1. Provision an Amazon EKS cluster using Pulumi.
2. Deploy the Helm chart to the EKS cluster.

Here is a step-by-step guide and the corresponding Pulumi program written in TypeScript to achieve this.

### Step 1: Provision an Amazon EKS Cluster
We'll create an EKS cluster using the `@pulumi/eks` high-level library, which simplifies EKS cluster creation. The `Cluster` resource from this library will automatically create the necessary AWS resources like the VPC, subnets, and security groups, along with the EKS cluster itself.

### Step 2: Deploy the Helm Chart
Then, we'll use the `@pulumi/kubernetes` package to deploy a Helm chart to the cluster. We will install the `simplified-ob-pattern-1` chart, which you would typically find in a Helm repository. For this example, I'll assume that the chart is available in a public or private Helm repo that you have access to.

Below is the full Pulumi program written in TypeScript to achieve this deployment. Please note that you should have Pulumi installed, AWS credentials configured, and the `pulumi` command available in your command line environment to run this program.

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

// Step 1: Creating a new EKS cluster
const cluster = new eks.Cluster("my-eks-cluster", {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    // Other configurations like instance type, VPC and subnet IDs can be set here.
});

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

// Step 2: Deploying a Helm Chart to the EKS cluster
// This assumes that you have the kubeconfig available and properly set up
// for your Kubernetes provider.

// Instantiate a Kubernetes provider with the kubeconfig from the created EKS cluster
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy Helm chart 'simplified-ob-pattern-1' to the EKS cluster
const helmChart = new kubernetes.helm.v3.Chart("my-helm-chart", {
    chart: "simplified-ob-pattern-1",
    // You might need to specify a 'repo' property here if the chart is not in the default repo,
    // or if it's in a private Helm repo.
    values: {
        // Chart-specific values go here.
    },
}, { provider: k8sProvider });

// Now, when you run `pulumi up`, Pulumi will create an EKS cluster and deploy
// the 'simplified-ob-pattern-1' Helm chart to it.
```

In this program, the `eks.Cluster` resource handles the creation of the AWS EKS cluster. The code assumes default settings for the VPC and subnets, but you may need to customize these depending on your requirements. You can also configure additional settings such as the node instance type and IAM roles.

We then create an instance of `kubernetes.Provider`, specifying the kubeconfig of the EKS cluster which allows Pulumi to deploy resources to that cluster.

Finally, we used the `kubernetes.helm.v3.Chart` resource to deploy the specified Helm chart. You may need to specify additional properties such as `repo` if the chart is hosted in a non-standard or private Helm repository.

After you write this program to a file (e.g., `index.ts`), you would run `pulumi up` in the same directory to execute it, which will provision the resources on AWS.

Please ensure to replace placeholders like the Helm chart name with actual values you intend to use. You may also need to set up any required AWS and Kubernetes RBAC permissions beforehand.