Deploy the redis-sentinel helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To accomplish the deployment of the Redis Sentinel Helm chart on AWS EKS using Pulumi, we'll go through the following steps:

1. Set up an EKS cluster: We'll use the `eks.Cluster` resource to provision a new EKS cluster on AWS.
2. Define an IAM role: Create an AWS IAM role needed by the EKS cluster for AWS services.
3. Deploy the Redis Sentinel Helm chart: We'll leverage the `kubernetes.helm.sh/v3.Chart` resource to deploy the chart onto our EKS cluster.

Here's the TypeScript Pulumi program to create the resources mentioned above:

```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 an EKS cluster.
const cluster = new eks.Cluster('my-cluster', {
  instanceType: 't2.medium',
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 3,
  // When creating a cluster, you can either provide a custom IAM Role or let the EKS component create one for you.
  createOidcProvider: true, // Required for IAM roles for Kubernetes service accounts
});

// Create a Kubernetes provider that uses our EKS cluster.
const k8sProvider = new k8s.Provider('k8s-provider', {
  kubeconfig: cluster.kubeconfig,
});

// Deploy the Redis Sentinel Helm chart using the Kubernetes provider.
const redisHelmChart = new k8s.helm.v3.Chart('redis-sentinel', {
  chart: 'redis',
  version: '10.7.16', // As an example, specify the version of the Redis Helm chart you'd like to deploy.
  fetchOpts: {
    repo: 'https://charts.bitnami.com/bitnami',
  },
  values: {
    // Specify any values that you want to override, e.g., use sentinel.enabled as true to enable sentinel.
    sentinel: {
      enabled: true,
    },
  },
}, { provider: k8sProvider });

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

// Export the Redis service endpoint to access it externally, if applicable.
export const redisService = redisHelmChart.getResource('v1/Service', 'my-cluster-redis-sentinel-master');
```

Here is an explanation of the resources and steps that will be executed with the above program:

- `eks.Cluster`: This resource is used to provision an EKS (Amazon Elastic Kubernetes Service) cluster. We specify the desired instance type, the minimum and maximum size of the cluster, and ensure that OIDC Provider is enabled for AWS IAM roles for Kubernetes service accounts.

- `k8s.Provider`: Once the EKS cluster is provisioned, we create this provider to interact with the cluster. It uses the generated `kubeconfig` from the EKS cluster which contains the necessary information to communicate with the cluster.

- `k8s.helm.v3.Chart`: This resource manages the deployment of Helm charts. We are using it to deploy the Redis Sentinel Helm chart. We specify the Helm repository URL and the version of the chart we'd like to deploy, along with any overrides we want for the chart values, such as enabling Redis Sentinel.

Finally, we export `kubeconfig` for accessing the cluster with `kubectl` or any Kubernetes compatible tool. We also export the Redis service endpoint for accessing the Redis instance externally if such access is set up in the Helm chart values.

**Note**: Before running this program, you will need to have Pulumi CLI set up and logged into a Pulumi account. Ensure that AWS credentials are configured for Pulumi to use either by setting up the AWS CLI or using environment variables. Please adjust the instance types, cluster size, and other configurations according to your requirements and make sure you have the necessary IAM policies attached to your Pulumi execution role.

After saving the above code in a file named `index.ts`, you can initialize a new Pulumi project using `pulumi new`, select the appropriate cloud (AWS, in this case), and run `pulumi up` to build and deploy the resources.