Deploy the redis-sed helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `redis-ha` Helm chart on AWS EKS (Elastic Kubernetes Service), you will need to follow these steps using Pulumi:

1. **Create an EKS Cluster**: An EKS cluster provides the Kubernetes control plane. You will need to define the networking resources like VPC, subnets, and the IAM role that Kubernetes will assume for AWS actions.

2. **Install the Helm Chart**: Once your Kubernetes cluster is up and running, you can deploy applications into it using Helm charts. Helm is a package manager for Kubernetes, allowing you to define, install, and upgrade even the most complex Kubernetes applications.

3. **Verify the Deployment**: After the deployment of the Helm chart, you should also consider verifying the status of the deployed resources.

Let's write a Pulumi program in TypeScript to deploy the `redis-ha` Helm chart to an EKS cluster.

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

// Create an EKS cluster with the default configuration.
const cluster = new eks.Cluster("my-cluster", {
    vpcId: vpc.id,
    subnetIds: vpc.privateSubnetIds,
});

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

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

// Deploy the Helm chart for redis-ha.
const redisHaChart = new k8s.helm.v3.Chart("redis-ha", {
    chart: "redis-ha",
    version: "4.3.6", // You may want to specify the exact chart version to use
    fetchOpts: { repo: "https://charts.bitnami.com/bitnami" }, // or the correct repository hosting the chart
    namespace: "default",
}, { provider });

// Export the cluster endpoint to enable accessing the Redis instance.
export const clusterEndpoint = cluster.core.endpoint;

// Export the Redis service endpoint within the cluster for in-cluster configurations.
export const redisServiceEndpoint = pulumi.interpolate`redis://${redisHaChart.getResourceProperty("v1/Service", "redis-ha", "status").apply(status => status.loadBalancer.ingress[0].hostname)}:6379`;
```

Here's a breakdown of the code:

1. **VPC Creation**: It's common to start by defining a VPC for the EKS cluster. This code uses the `awsx` library for convenience, creating a VPC with both public and private subnets.

2. **EKS Cluster Creation**: The EKS cluster `my-cluster` is created using the `eks` Pulumi package, taking care to pass our VPC details. This will set up the Kubernetes control plane and node groups for running the workload.

3. **Kubeconfig Export**: Once the cluster is created, you need access to the `kubeconfig` to communicate with the cluster. It is exported as a stack output.

4. **Kubernetes Provider Setup**: Communication with the EKS cluster from Pulumi uses the `kubernetes` provider. It requires the `kubeconfig` for authentication.

5. **Helm Chart Deployment**: The `redis-ha` Helm chart is then deployed. The `Chart` resource is used from the `kubernetes` package.

6. **Service Endpoint Export**: This exports the Kubernetes service's endpoint for Redis, which allows you to access Redis from within the cluster.

7. **Cluster Endpoint Export**: This provides the EKS cluster endpoint, which allows access to the cluster API server from outside the cluster.

To deploy this program:

1. Install [Pulumi](https://www.pulumi.com/docs/get-started/aws/begin/) and AWS CLI.
2. Configure AWS CLI with `aws configure`.
3. Run `pulumi up` to deploy the stack.

Remember to replace the Helm chart version and the repository URL with the appropriate values for the version of the `redis-ha` chart that you would like to deploy.

After successful deployment, you can manage your Redis instance through the Kubernetes API using tools like `kubectl` configured with the output `kubeconfig`.

Please note that this program assumes you have the necessary permissions to create and manage AWS and EKS resources within your AWS account.