Deploy the ververica-platform-crd helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Ververica Platform Community Edition using Helm on an AWS EKS cluster with Pulumi, you will need to:

1. Set up an Amazon EKS cluster.
2. Configure an ECR repository if your application requires custom Docker images.
3. Install the Helm chart for Ververica Platform.

Below is a program written in TypeScript that demonstrates these steps.

### Program Explanation
- **EKS Cluster**: We'll begin by creating an EKS cluster using Pulumi's `eks` package. This cluster will be where we deploy our applications.
- **ECR Repository**: If needed, we will set up an Elastic Container Registry (ECR) Repository to store Docker images. Ververica Platform might require custom images based on your application needs.
- **Ververica Platform Helm Chart**: Finally, we'll deploy the Ververica Platform Helm chart to our EKS cluster using the `kubernetes` package.

Each resource will include documentation links for further reading.

Let's start with our TypeScript program:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster('ververica-cluster', {
    instanceType: 't2.medium', // For smaller workloads; you may need larger instance based on your needs
    desiredCapacity: 2,        // Desired number of instances in the EKS cluster
    minSize: 1,                // Minimum number of instances
    maxSize: 3,                // Maximum number of instances
    storageClasses: 'gp2',     // The default gp2 storage class
});

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

// Step 2: Set up an ECR repository (optional, uncomment if needed)
/* const repository = new awsx.ecr.Repository('ververica-repo', {
    imageTagMutability: "MUTABLE", // Specifies whether images are mutable or immutable.
});

// Export the ECR repository URL.
export const repositoryUrl = repository.repositoryUrl; */

// Step 3: Deploy the Ververica Platform Helm chart
const ververicaChart = new k8s.helm.v3.Chart('ververica-platform-chart', {
    chart: 'ververica-platform',     // The name of the chart
    version: '5.3.0',                // Specify the version of the chart
    fetchOpts: {
        // Specify the repo if it's a third-party chart, for example
        // repo: 'https://charts.ververica.com',
    },
    namespace: 'ververica',          // The namespace for deploying the helm chart
    values: {
        // Provide specific values here for the Helm chart if necessary
    },
}, { provider: cluster.provider });

// When a program runs `pulumi up`, Pulumi will ensure that these resources are
// properly created and configured before marking the deployment as successful.
```

### Helm Chart Notes
- The `ververica-platform` Helm chart and its version (`5.3.0` in the example) should match the current offerings from Ververica. You may need to adjust the chart name and version according to what is available.
- The `repo` in the `fetchOpts` is commented out as an example. If the Ververica Platform chart is published on a third-party Helm repository, you'll need to uncomment it and provide the appropriate URL.
- `values` is where you can pass any necessary configurations that the Ververica Platform Helm chart accepts. For a full list of configurable values, refer to the official Helm chart's `values.yaml` file or its documentation.

### Running the Program

To run this Pulumi program, you'll first need to set up the Pulumi CLI and AWS CLI, and configure your AWS credentials. You also need Node.js and `npm` installed to run the TypeScript program. Once your AWS account is configured and you have authenticated via the AWS CLI:

1. Create a new directory for your Pulumi project.
2. Use `npm` to create a `package.json` file and install the Pulumi EKS, AWSX, and Kubernetes packages.
3. Paste the