Deploy the pmm-server helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `pmm-server` Helm chart on AWS EKS (Elastic Kubernetes Service) using Pulumi, we will follow several steps:

1. **Create an EKS Cluster**: Use `aws.eks.Cluster` which provisions a managed Kubernetes cluster.
2. **Create an ECR Repository (optional)**: If the `pmm-server` image needs to be stored in AWS ECR, use `aws.ecr.Repository`.
3. **Install the Helm Chart**: Utilize a Pulumi component that can deploy Helm charts on a Kubernetes cluster, such as `pulumi/kubernetes`.

I'll provide you with a TypeScript program that performs these tasks. Make sure you have Helm, `kubectl`, and Pulumi installed and configured correctly for the AWS account.

Here's a detailed Pulumi TypeScript program to achieve this:

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

// Step 1: Create an EKS Cluster.
// Reference: https://www.pulumi.com/registry/packages/aws/api-docs/eks/cluster/
const cluster = new eks.Cluster("my-cluster", {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2",
    deployDashboard: false,
});

// Step 2 (Optional): Create an ECR Repository if using a custom pmm-server image.
// Uncomment the following lines if you need a private ECR repo for your Helm chart images.
// Reference: https://www.pulumi.com/registry/packages/aws/api-docs/ecr/repository/
/*
const repo = new aws.ecr.Repository("my-repo", {
    imageScanningConfiguration: {
        scanOnPush: true,
    },
    imageTagMutability: "MUTABLE",
});
*/

// Step 3: Install the pmm-server Helm chart on the created EKS cluster.
// This assumes that pmm-server is publicly available from a Helm chart repository,
// replace "chart-repo-url" with the actual chart repository URL and "chart-version" with the chart version.
// Reference to Pulumi Kubernetes: https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/
const pmmServerChart = new k8s.helm.v3.Chart("pmm-server", {
    chart: "pmm-server",
    version: "chart-version", // replace with the actual chart version
    fetchOpts: {
        repo: "chart-repo-url", // replace with the actual chart repository URL
    },
}, { provider: cluster.provider });

// Step 4: Export the cluster's kubeconfig and the chart's status.
export const kubeconfig = cluster.kubeconfig;
export const chartStatus = pmmServerChart.status;
```

This program does the following:
- **Step 1**: Creates an EKS cluster with 2 `t2.medium` instances, scaling between 1 and 2 as necessary.
- **Step 2 (Optional)**: Provides commented-out code to create an ECR repository if you're using a private container image for the Helm chart.
- **Step 3**: Deploys the `pmm-server` Helm chart to the EKS cluster. You will need to specify the chart name, chart repository URL, and version.
- **Step 4**: Exports the kubeconfig for the EKS cluster and the status of the Helm chart deployment, so you can access the Kubernetes cluster and check the deployment status.

Each resource is instantiated using classes from the respective Pulumi AWS and Kubernetes libraries, and you can customize properties such as instance types, cluster size, and more, based on your requirements. Remember to replace `chart-version` and `chart-repo-url` with the actual chart version and repository URL. If you're using a private image stored in ECR, you'll need to uncomment and configure the ECR repository section.

To run this Pulumi program, save it to a TypeScript file, run `pulumi up` in the directory containing the file, and follow the command-line prompts to provision the resources. After the deployment completes, you will get the kubeconfig needed to interact with your EKS cluster with `kubectl`.