Deploy the statefulset helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a StatefulSet Helm Chart on an AWS EKS cluster using Pulumi, you'll first need to set up an EKS cluster. After that, you can use Pulumi's Kubernetes provider to deploy a Helm Chart, including those that create StatefulSets. Below we'll walk through the process step by step.

### Setting Up the EKS Cluster

We'll begin by creating an EKS cluster, which serves as the environment for deploying our Helm chart. Pulumi provides higher-level abstractions for EKS through the `eks` package, which simplifies cluster creation and management.

### Deploying the Helm Chart

Once the cluster is ready, we'll deploy the StatefulSet Helm Chart to the EKS cluster. We use the `kubernetes.helm.v3.Chart` resource from the `@pulumi/kubernetes` package to apply a Helm Chart.

Here's a detailed TypeScript program that performs the following:

1. Creates a new EKS cluster.
2. Deploys a Helm chart for a StatefulSet.

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

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

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

// Create a provider for the EKS cluster.
const provider = new k8s.Provider("provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Use the `kubernetes.helm.sh/v3.Chart` resource to deploy a Helm Chart that includes a StatefulSet.
const statefulSetChart = new k8s.helm.v3.Chart("my-statefulset", {
    chart: "my-statefulset-chart-name",
    // Optionally specify the Helm repository.
    // If your Helm chart is in a public repository, you can specify `repo: "URL"` here.
    // Replace "1.0.0" with the chart version you want to deploy.
    version: "1.0.0",
    // You can include custom values for the Helm chart by specifying the `values` field.
    // For example:
    // values: {
    //   size: 3,
    //   user: "admin",
    // },
}, { provider });

// Export the public Endpoint of the EKS cluster.
export const clusterEndpoint = cluster.core.endpoint;

// (1) Detailed explanations of the resources used:

// - `eks.Cluster` is used to create an AWS EKS Kubernetes cluster. The cluster's `kubeconfig` is exported
//   so that you can interact with the cluster using `kubectl` or any Kubernetes client.
//   [EKS Cluster](https://www.pulumi.com/registry/packages/eks/api-docs/cluster/)

// - `kubernetes.Provider` is a Pulumi resource that provides a way to interact with your Kubernetes cluster.
//   We configure this with the `kubeconfig` of the EKS cluster so that it points to our newly created cluster.
//   [Kubernetes Provider](https://www.pulumi.com/registry/packages/kubernetes/api-docs/provider/)

// - `kubernetes.helm.v3.Chart` is used to deploy a Helm chart into a Kubernetes cluster. Pulumi automatically
//   translates the Helm chart into the respective Kubernetes resources and handles the deployment.
//   [Helm Chart](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/)

// (2) Why we're using these resources:

// We use these resources because they provide high-level abstractions that make it easier to create and manage AWS EKS clusters and deploy applications to them using Helm charts.
```

The program above automates the creation of your AWS EKS cluster and deploys a Helm chart representing your StatefulSet. We assume here that the Helm chart named "my-statefulset-chart-name" is a publicly available Helm chart and replace it with your specific Helm chart's name.

### Things to Consider

- **Helm Chart Details**: The chart's `repo` and `version` should be specified if it's not a chart that's included in the default repository. Additionally, `values` can be customized based on the chart's configurable parameters.
- **Pulumi Stacks**: Pulumi uses stacks to manage different deployments environments (like dev, staging, prod). Remember that running pulumi up with the above code will try to provision resources in the current stack.
- **AWS Credentials**: Ensure your AWS credentials are set up correctly for Pulumi to manage resources on your behalf.
- **CLI Tools**: You should have the Pulumi CLI and the AWS CLI pre-installed and configured.
- **StatefulSet Persistence**: StatefulSets often require persistent storage. Ensure that your Helm chart and EKS setup account for persistent volumes so stateful services can maintain their state across pod restarts.

After finishing the code, you can run the Pulumi CLI commands `pulumi up` to create the resources and deploy the chart. After deployment, `kubectl` can be used with the exported kubeconfig to interact with the cluster.