Deploy the redis-ui helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `redis-ui` Helm chart on an AWS Elastic Kubernetes Service (EKS) cluster using Pulumi, here's what we need to do:

1. Create an EKS cluster: This serves as the environment where your Kubernetes resources will run.
2. Install the Helm chart on the EKS cluster: We'll use Pulumi's Kubernetes provider to deploy the `redis-ui` Helm chart.

We're leveraging the `awsx` and `eks` packages to create the EKS cluster easily and the `kubernetes` package to deploy the Helm chart.

Below is the step-by-step Pulumi program written in TypeScript:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster('my-eks-cluster', {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2", // default storage class
    deployDashboard: false, /* optional, recommended to be false for security */
});

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

// Step 2: Install the redis-ui Helm chart on the EKS cluster
// First, we need a provider that uses the kubeconfig from our new EKS cluster
const provider = new k8s.Provider('eks-k8s', {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Now we can use this provider to install the Helm chart into the cluster.
const redisUiChart = new k8s.helm.v3.Chart('redis-ui', {
    chart: 'redis-ui',
    version: 'x.y.z', // replace with the desired chart version
    fetchOpts: {
        repo: 'http://charts.example.com/', // replace with the Helm chart repository
    },
}, { provider });

// Export the Redis UI service endpoint
export const redisUiEndpoint = redisUiChart.getResourceProperty('v1/Service', 'redis-ui-redis-ui', 'status')
    .apply(status => status.loadBalancer.ingress[0].ip);

```

**Explanation**:
- We create a new EKS cluster named `my-eks-cluster`. You can customize instance types and autoscaling parameters as per your requirements.
- The kubeconfig for the cluster is exported so you can interact with the cluster using kubectl or other tools.
- A new Pulumi Kubernetes provider is created to interact with the EKS cluster.
- We then declare a Helm chart resource named `redis-ui`. You would replace `'x.y.z'` with the specific version of the Redis UI Helm chart you wish to install and `'http://charts.example.com/'` with the actual Helm chart repository URL.
- Finally, we export the endpoint of the Redis UI service. This implies the service type is LoadBalancer and will provision an external IP.

**Important Notes**:
- Be sure to replace `'x.y.z'` and `'http://charts.example.com/'` in the `Chart` resource with actual values.
- Depending on how the `redis-ui` service is configured in the Helm chart, you may need to adjust the `redisUiEndpoint` export to match the correct properties.
- Adjust `desiredCapacity`, `minSize`, and `maxSize` to handle your workload appropriately.
- Set `deployDashboard` according to your security practices; it's generally discouraged to enable it due to its broad permissions.
- Helm charts have dependencies on certain storage classes, such as `gp2`. Ensure you have the storage classes configured as required by the `redis-ui` chart.
- Review and modify security groups or access roles as needed for your specific environment and security requirements.

Once you apply this Pulumi program, the AWS EKS cluster will be created, and the Redis UI Helm chart will be installed on the cluster. You'll be able to interact with the EKS cluster using the outputted `kubeconfig` and access the Redis UI at the `redisUiEndpoint`.