Deploy the dapr-dashboard helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Dapr dashboard Helm chart on an AWS Elastic Kubernetes Service (EKS) cluster, we will need to follow several steps:

1. **Create an EKS cluster**: We will use Pulumi's AWS provider to create an EKS cluster.
2. **Configure `kubectl`**: Pulumi allows us to automatically configure the `kubectl` context, which we will use for interacting with the Kubernetes cluster.
3. **Install the Helm chart**: We will use Pulumi's Kubernetes provider to deploy the Dapr dashboard by specifying the Helm chart in the Pulumi program.

Below is a detailed explanation followed by a TypeScript program that carries out these steps.

### Detailed Explanation

#### EKS Cluster Creation

We start by creating an EKS cluster using `aws.eks.Cluster`. We must specify certain required properties like `roleArn` for the IAM role that provides permissions for the EKS cluster and `vpcConfig` to establish the VPC where the cluster will be running. The cluster will also need a `nodegroup` to provision worker nodes that the Kubernetes pods would be scheduled on.

#### Configure kubectl

Pulumi's EKS library provides abstractions to work with Kubernetes resources. Once the EKS cluster is provisioned, Pulumi can automatically configure `kubectl` to interact with the cluster by setting up the necessary kubeconfig.

#### Helm Chart Installation

Dapr's dashboard can be installed using its Helm chart. We will refer to `kubernetes.helm.v3.Chart` to deploy the Dapr dashboard Helm chart. We need to specify the chart name and repository location within the `Chart` resource, along with any configuration values required by the Helm chart.

Let's proceed with the program:

```typescript
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", {
    // Reference the correct role and subnets from your environment
    roleArn: "arn:aws:iam::123456789012:role/EksClusterRole", 
    vpcConfig: {
        // Replace with the appropriate VPC ID and subnet IDs for your environment
        vpcId: "vpc-0abcdef1234567890", 
        subnetIds: ["subnet-abcdef01234567890", "subnet-0123456789abcdef0"],
    },
});

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

// Create a Helm chart resource that deploys the Dapr dashboard
const daprDashboardChart = new k8s.helm.v3.Chart("dapr-dashboard", {
    chart: "dapr-dashboard",
    version: "x.y.z", // Replace with the specific chart version you want to deploy
    fetchOpts: {
        repo: "https://dapr.github.io/helm-charts/",
    },
}, { provider: cluster.provider });

// Export the dashboard URL
export const dashboardUrl = cluster.getKubernetesDashboardUrl();
```

In the above TypeScript program, replace the placeholders for the `roleArn`, `vpcId`, and `subnetIds` with the actual values from your AWS environment. Also, update the chart version to the version you intend to use.

Once you run this code with Pulumi (`pulumi up`), it will initiate the creation of an EKS cluster and, after that, deploy the Dapr dashboard using the Helm chart. The cluster's kubeconfig is exported, which can be used to interact with your EKS cluster. Additionally, the dashboard URL is also exported, which you can use to access the dashboard once it is deployed.

Remember that creating an EKS cluster can incur costs in your AWS account, and the creation process can take several minutes to complete. Be patient and check the Pulumi CLI output for progress updates. After the deployment, make sure to manage the resources appropriately to avoid unnecessary charges.