Deploy the ibm-websphere-traditional helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the IBM WebSphere Traditional Helm chart on an AWS EKS cluster using Pulumi, you need to perform several steps. First, you'll set up an EKS cluster in AWS. Then, you'll deploy the Helm chart to this cluster.

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

1. **Create an EKS Cluster**: You will use the `aws.eks.Cluster` resource to create an EKS cluster. This is a managed Kubernetes service that handles the complexity of running Kubernetes.

2. **Define an IAM Role for EKS**: The cluster needs an IAM role (`aws-iam.EKSRole`) so that AWS resources can interact with your Kubernetes cluster.

3. **Deploy the Helm Chart**: Once the cluster is up, you can deploy Helm charts using the `kubernetes.helm.v3.Chart` resource. This will pull the `ibm-websphere-traditional` chart from the specified Helm repository and deploy it to your EKS cluster.

4. **Obtain the Kubernetes Provider**: To interact with the newly created EKS cluster, you will need to use the Kubernetes provider configured with the credentials to access the EKS cluster. This is done automatically by using the kubeconfig output from the EKS cluster.

Now, here's the Pulumi TypeScript program:

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

// Create an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    // Minimally configure the EKS cluster.
    name: "my-cluster",
    version: "1.21",
    instanceType: "t3.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
});

// Export the cluster 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.apply(JSON.stringify),
});

// Deploy the IBM WebSphere Traditional Helm chart.
const ibmWebsphereChart = new k8s.helm.v3.Chart("ibm-websphere-chart", {
    chart: "ibm-websphere-traditional",
    // Specify the Helm repository here if it's not already added (e.g., `repo: "http://myhelmrepo.org"`).
    // You must provide the repository that hosts the `ibm-websphere-traditional` chart.
    // Specify the chart version to deploy, for example: version: "x.y.z"
    // You can also provide custom values by using the `values` property.
}, { provider });
```

This program first initializes the EKS cluster with default settings. After the cluster is created, we define a Kubernetes provider that knows how to communicate with our EKS cluster using the generated kubeconfig. Then we deploy the IBM WebSphere Traditional Helm chart using the `Chart` resource from the Pulumi Kubernetes provider.

After the code is deployed, you can use `pulumi up` to provision the resources on AWS. Once deployment is complete, `kubeconfig` will hold the configuration needed to communicate with your Kubernetes cluster, and you can use `kubectl` with this configuration to interact with your cluster.