Deploy the redis-replication helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `redis-replication` Helm chart on AWS EKS with Pulumi, we will follow these steps:

1. **Create an EKS cluster**: We will use the `aws.eks.Cluster` resource to provision a new EKS cluster.
2. **Deploy the Helm chart**: Once the cluster is up and running, we will use the `pulumi/kubernetes` package to deploy the `redis-replication` Helm chart to the EKS cluster.

Firstly, let's set up our EKS cluster using Pulumi's `aws` and `awsx` (AWS Crosswalk) packages, which provide higher-level abstractions and best-practice defaults:

```typescript
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 a VPC for our cluster
const vpc = new awsx.ec2.Vpc("myVpc", { numberOfAvailabilityZones: 2 });

// Create an EKS cluster with the default configuration.
const cluster = new eks.Cluster("myCluster", {
    vpcId: vpc.id,
    privateSubnetIds: vpc.privateSubnetIds,
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2",
    deployDashboard: false,
});

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

The above TypeScript code will provision an EKS cluster along with a new VPC configured with two availability zones. We are also configuring the node group with an instance type of `t2.medium` and setting desired, min, and max capacity of the autoscaling group.

Next, we will deploy the `redis-replication` Helm chart to the EKS cluster. For that, we'll need to install the Kubernetes package from Pulumi and use the `k8s.helm.v3.Chart` resource:

```typescript
// Use the pulumi/kubernetes provider to interact with the created EKS cluster.
const provider = new k8s.Provider("k8s", { kubeconfig: cluster.kubeconfig });

// Deploy the Redis Helm chart using the Redis replication values.
const redisReplicationChart = new k8s.helm.v3.Chart("redis-ha", {
    chart: "redis",
    version: "10.5.7", // Ensure you have the correct version here
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        cluster: {
            enabled: true,
            slaveCount: 2,
        },
        global: {
            storageClass: "gp2",
        },
    },
}, { provider: provider });

// Export the endpoint of the Redis master service.
export const redisMasterEndpoint = redisReplicationChart.getResourceProperty(
    "v1/Service", "redis-ha-master", "status"
).apply(status => status.loadBalancer.ingress[0].hostname);
```

The code above defines a new Helm chart resource that points to the `redis` chart from the Bitnami Helm repository (note that typically Bitnami does not provide a chart named `redis-replication`, so here we're assuming we're using the `redis` chart with configuration set for replication). We use the `redis-ha` (High Availability) configuration, which is effectively a replicated setup. The `values` object is used to configure the chart, enabling a Redis cluster mode with one master and two replicas, and using `gp2` as the storage class.

Now we export the endpoint that we can use to connect to our Redis master service. This will be a part of your Pulumi stack's output.

Note: Before running this code with Pulumi, you will need to install the necessary Pulumi packages by running:

```bash
pulumi plugin install resource aws v4.0.0 # Replace with the actual version you need
pulumi plugin install resource kubernetes v3.0.0 # Replace with the actual version you need
npm install @pulumi/aws @pulumi/awsx @pulumi/eks @pulumi/kubernetes
```

To deploy this Pulumi program, run `pulumi up` in the directory where this program is saved. Pulumi will perform the deployment and provide you with the outputs, including the `kubeconfig` and `redisMasterEndpoint`, which you can use to interact with your EKS cluster and Redis deployment.