Deploy the dynamo-db helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy a DynamoDB Helm chart to an Amazon EKS (Elastic Kubernetes Service) cluster using Pulumi, you'll first need an EKS cluster to deploy to. This process entails the following steps:

Creating an EKS cluster.
Using a Helm chart to deploy DynamoDB on that EKS cluster.

Below is a detailed explanation of how to perform these steps using Pulumi with TypeScript, followed by the complete Pulumi program.

Setup the EKS Cluster

To start, we'll create an EKS cluster. We'll use the pulumi/eks package, which provides a high-level interface for creating and managing an EKS cluster. This Pulumi component abstracts away many of the finer details involved in setting up an EKS cluster, making it easier to work with.

The cluster will require certain specifications such as the desired version of Kubernetes, the IAM role for the cluster, the VPC configuration, and other cluster settings. We'll assume that we want to create a new VPC for our cluster, but be aware that you could also reference an existing VPC.

Deploying the Helm Chart

Once the EKS cluster is ready, we'll deploy the DynamoDB Helm chart. For this, we will be utilizing the pulumi/kubernetes package which allows us to leverage Helm charts directly. Pulumi's Chart resource will interact with the Helm package manager to install the chart.

The DynamoDB Helm chart needs to be available in a public or private Helm repository, or you may have it locally. For this example, we'll assume there's a DynamoDB chart available in a public repository.

Before you begin, ensure you have the AWS and Pulumi CLIs installed and configured with the necessary credentials and settings.

Now, let's look at the TypeScript program that performs the tasks we've described.

import * as pulumi from "@pulumi/pulumi";
import * as eks from "@pulumi/eks";
import * as k8s from "@pulumi/kubernetes";

// Step 1: Create an EKS cluster.
const cluster = new eks.Cluster("eks-cluster", {
    // Specify the desired Kubernetes version for your cluster.
    version: "1.21",
    // The `instanceType` and `desiredCapacity` parameters determine the size and capacity of your cluster's node group.
    instanceType: "t2.medium",
    desiredCapacity: 2, // Adjust this number based on your workload requirements.
    minSize: 1,
    maxSize: 3,
});

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

// Step 2: Deploy the DynamoDB Helm chart onto the EKS cluster. This assumes you have a Helm chart named 'dynamodb'.
const dynamoDbChart = new k8s.helm.v3.Chart("dynamo-db", {
    chart: "dynamodb",
    // Replace `<REPO_NAME>` with the name of the repository that contains the chart.
    // Replace `<VERSION>` with the specific version of the chart you want to deploy, if applicable.
    repo: "<REPO_NAME>",
    version: "<VERSION>",
    // You can specify additional configuration options here. For DynamoDB, you might want to tailor your configuration to your needs.
    values: {
        // Add your custom values here. Refer to the chart's documentation for available options.
    },
}, { provider: cluster.provider });

// Ensure the EKS cluster is ready before we try installing the Helm chart.
const helmChart = dynamoDbChart.getResource("v1/Service", "dynamo-db", resource => resource.isReady);

// Export the URL to access the DynamoDB service, assuming the chart exposes DynamoDB via a LoadBalancer service.
export const dynamoDbServiceUrl = helmChart.status.apply(status => status.loadBalancer.ingress[0].hostname);

Before running this Pulumi program, replace <REPO_NAME> and <VERSION> with the relevant information for your DynamoDB Helm chart.

To apply this script with Pulumi:

Save your code in a file with a .ts extension.
Use pulumi up in the command line interface from the same directory as your script to start the deployment process.

This program first sets up an EKS cluster with a desired configuration, such as the Kubernetes version and the number and type of nodes. Once the cluster is provisioned, it then uses Pulumi's Helm Chart resource to deploy DynamoDB from the specified Helm chart repository.

Keep in mind that a real-world usage might involve specifying more configuration parameters, setting up an existing VPC, or using additional AWS and Kubernetes resources. The values and versions should be chosen based on the actual requirements and available Helm charts for DynamoDB or the specific datastore you need.

In the output, the program exports the kubeconfig needed to access the cluster with kubectl and the URL to access the deployed DynamoDB, provided it exposes an external endpoint.