Deploy the redis-setup helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a Helm chart for Redis on Amazon EKS (Elastic Kubernetes Service), you'll need to create an EKS cluster, configure the Kubernetes provider to communicate with the cluster, and deploy the Redis Helm chart onto the cluster.

Here's a step-by-step guide on how you can achieve this using Pulumi with TypeScript:

### Creating an EKS Cluster
We will start by creating an EKS cluster using the `eks.Cluster` resource from the Pulumi EKS package. This package provides a high-level component that wraps the configuration and creation of an EKS cluster and its node groups.

### Configuring Kubernetes Provider
Once the EKS cluster is created, we will configure the Kubernetes provider to use the generated kubeconfig from the cluster creation process. This provider will be used to interact with the Kubernetes API to deploy the Redis Helm chart.

### Deploying Redis Helm Chart
We will then use the `helm.v3.Chart` resource from Pulumi's Kubernetes package to deploy the Redis Helm chart. This allows us to manage Helm charts in a declarative way using infrastructure as code.

Here's the Pulumi TypeScript program to accomplish the deployment:

```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("redis-cluster", {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2",
    deployDashboard: false,
});

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

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the redis Helm chart using the created k8s provider.
const redisChart = new k8s.helm.v3.Chart("redis-helm", {
    chart: "redis",
    version: "10.5.7",
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: k8sProvider });

// Export the Redis host so we can easily access it.
export const redisHost = redisChart.getResourceProperty("v1/Service", "redis-helm-redis-master", "status").apply(s => s["loadBalancer"]["ingress"][0]["hostname"]);

```

In this program:

- We initialize an EKS cluster with `eks.Cluster`, specifying the desired capacity and size constraints for our nodes.
- We export the `kubeconfig` which is necessary to communicate with the cluster using `kubectl` or any Kubernetes client library.
- We then create a `Provider` which represents the ability to communicate with the cluster using the `kubeconfig`.
- We deploy the Redis Helm chart by creating an instance of `helm.v3.Chart`, specifying the chart name, version, and repository.
- We export the Redis host using `getResourceProperty` to get the generated endpoint from the created Redis service. This allows you to connect to your Redis instance once the deployment is complete.

Remember to install all necessary npm packages for this Pulumi program to work:

```bash
npm install @pulumi/pulumi @pulumi/aws @pulumi/eks @pulumi/kubernetes
```

Please note that running this program will create resources in AWS, and charges may apply. Make sure to destroy the resources after you're done experimenting to avoid unwanted costs:

```bash
pulumi destroy
```

This Pulumi program is a comprehensive approach to deploy a Helm chart on the AWS EKS cluster, providing a scalable and maintainable Redis setup in the cloud.