Deploy the prometheus-container-resource-exporter helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Prometheus Container Resource Exporter Helm chart on AWS EKS using Pulumi, we would go through the following steps:

1. Set up an Amazon EKS (Elastic Kubernetes Service) cluster.
2. Deploy the Prometheus Helm chart on the EKS cluster.

First, we need to make sure the Pulumi CLI is installed and configured with the necessary AWS credentials in our environment to create and manage resources on AWS.

Next, we will use Pulumi's AWS EKS package to create an EKS cluster. The `eks.Cluster` resource from Pulumi simplifies the creation of an EKS cluster by encapsulating much of the required configuration.

Once we have the EKS cluster ready, we will then deploy the Prometheus Container Resource Exporter using the `kubernetes.helm.v3.Chart` resource, which allows us to deploy Helm charts to a Kubernetes cluster.

Let's proceed with the TypeScript program:

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

// Step 1: Create an EKS Cluster
const vpc = new awsx.ec2.Vpc("my-vpc", {numberOfAvailabilityZones: 2}); // Create a new VPC for our cluster
const cluster = new eks.Cluster("my-cluster", {
    vpcId: vpc.id,
    subnetIds: vpc.publicSubnetIds,
    instanceType: "t2.medium", // Be sure to choose an instance type that suits your needs
    desiredCapacity: 2, // Number of worker nodes
    minSize: 1,
    maxSize: 3,
});

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

// Step 2: Deploy the Prometheus Helm Chart
const prometheusChart = new k8s.helm.v3.Chart("prometheus-chart", {
    chart: "prometheus",
    fetchOpts: {
        repo: "https://prometheus-community.github.io/helm-charts",
    },
    // Specify the values for the Container Resource Exporter.
    values: {
        // Here we would customize our Prometheus deployment
        // For example, enabling the servicemonitor for the Container Resource Exporter.
        // Change `enabled` to true and configure as needed for your context.
        serviceMonitor: {
            containerExporter: {
                enabled: false, // Change this to `true` to enable.
            },
        },
    },
}, {provider: new k8s.Provider("k8s-provider", {kubeconfig: cluster.kubeconfig})});

// Additional commands or configurations go here.

```

Let's explain the code above:

- We create a new VPC dedicated to the EKS cluster, which includes public subnets spread across two Availability Zones for high availability.
- Next, we create the EKS cluster itself, setting the `vpcId` and `subnetIds` to those of the VPC we just created. We define the desired capacity, minimum, and maximum size of our worker node group to control its scaling.
- We export the `kubeconfig` which is necessary to communicate with our cluster using tools like `kubectl` or in programming libraries.
- We then deploy the Prometheus Container Resource Exporter Helm chart to the EKS cluster by creating a `Chart` resource. We specify the Helm chart to deploy by providing the chart name and the repository it belongs to.
- The `values` object within the `Chart` resource allows us to customize our deployment. As an example, enabling service monitors for Prometheus is shown, but in the context of the Container Resource Exporter, you would adjust these settings according to your specific needs. If you need the Container Resource Exporter, you must enable it and configure it to meet your requirements.
- Finally, we establish a K8s provider with the generated kubeconfig from the EKS cluster so that the Helm chart can be deployed to the correct Kubernetes cluster.

The above program is a comprehensive guide to deploying Prometheus in an AWS EKS environment using Pulumi and TypeScript. Please adjust the instance types, scaling parameters, and Prometheus settings according to your specific application's needs and resources.