Deploy the yet-another-cloudwatch-exporter helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the "yet-another-cloudwatch-exporter" Helm chart on AWS EKS using Pulumi, you'll need to perform the following main steps:

1. Create an Amazon EKS (Elastic Kubernetes Service) cluster.
2. Configure Pulumi with access to your EKS cluster.
3. Deploy the Helm chart to your EKS cluster.

Below you'll find a detailed Pulumi program written in TypeScript that accomplishes these steps. The program first creates an EKS cluster using the high-level `eks.Cluster` resource from the Pulumi EKS package. With the cluster in place, we can then use the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider to deploy "yet-another-cloudwatch-exporter" from Helm.

Here's the program with annotations to guide you through it:

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

// Create an EKS cluster.
const cluster = new eks.Cluster("myCluster", {
    // Specify the desired Kubernetes version. Check the Pulumi EKS package for default and available versions.
    version: "1.21",

// You can specify the node instance type according to your needs.
    instanceType: "t2.medium",

// Define the number of cluster nodes.
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
});

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

// After the EKS cluster is up and running, we can deploy the Helm chart using a Pulumi Kubernetes Provider.
// First, we set up a provider that uses our kubeconfig to access the cluster.
const clusterProvider = new kubernetes.Provider("clusterProvider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Next, we deploy the 'yet-another-cloudwatch-exporter' Helm chart to our cluster with the provider.
const chart = new kubernetes.helm.v3.Chart("yet-another-cloudwatch-exporter", {
    chart: "yet-another-cloudwatch-exporter",
    version: "5.1.0", // Make sure to specify the correct chart version.
    repositoryOpts: {
        repo: "https://prometheus-community.github.io/helm-charts", // Chart's repository URL.
    },
    // If needed, specify the values to configure the chart.
    values: {
        // Refer to the chart's values.yaml file or the chart's documentation for possible configuration options.
        // For example, we can set the serviceAccount name or AWS region (although they have sensible defaults).
        // serviceAccount: {
        //     name: "exporter-sa",
        // },
        // aws: {
        //     region: "us-west-2",
        // },
    },
}, { provider: clusterProvider });

// Optionally, you can export endpoints or other resources created by the chart.
export const chartName = chart.getResourceProperty("v1/Service", "yet-another-cloudwatch-exporter", "metadata").name;
```

This program first creates a new EKS cluster with a specified Kubernetes version and node size. The `desiredCapacity`, `minSize`, and `maxSize` settings determine the scaling properties of your node group.

Once the cluster is up and running, the program sets up a Kubernetes provider for Pulumi that uses the cluster's `kubeconfig`. This allows Pulumi to communicate with your EKS cluster.

With the provider configured, the program then deploys the "yet-another-cloudwatch-exporter" Helm chart. Note that you need to specify the correct Helm chart version and repository URL. The `values` section is where you can customize the Helm chart configuration by referring to the chart's `values.yaml` file or official documentation.

Finally, the program exports the `kubeconfig` and the name of the deployed Chart's Kubernetes Service, which you can use to connect to your "yet-another-cloudwatch-exporter" deployment.

Remember that you must have AWS CLI configured with the proper permissions and Pulumi CLI installed to run this Pulumi program. Save the program in a file named `index.ts` and, from the same directory, run `pulumi up` to create the resources. The output will display the values that have been exported, such as the cluster's `kubeconfig`.