Deploy the rds-exporter helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `rds-exporter` Helm chart on AWS EKS, we'll go through several steps to establish the necessary infrastructure and deploy the chart. You will need an EKS cluster to deploy your Helm chart.

Below is a comprehensive Pulumi program written in TypeScript that will:

1. Create an EKS cluster using Pulumi's `eks` package, which is a high-level component that simplifies EKS cluster creation.
2. Deploy the `rds-exporter` Helm chart to the EKS cluster.

Before you run this program, make sure that you have:
- Installed Pulumi CLI and configured AWS credentials.
- Installed `kubectl` command-line tool to interact with the Kubernetes cluster.
- Installed Node.js and the `@pulumi/eks` package.

Here's the Pulumi TypeScript program:

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

// Create a new EKS cluster. The 'eks.Cluster' resource encapsulates all the state
// necessary to create a usable EKS cluster, including the control plane,
// worker nodes and networking infrastructure.
const cluster = new eks.Cluster("my-cluster", {
    // Specify the desired version for your Kubernetes cluster.
    // Version upgrades are managed by changing this value.
    version: "1.21",
    // By default, 'eks.Cluster' creates a managed node group. Configuring 'nodeGroupOptions'
    // allows customization of the node group(s).
    nodeGroupOptions: {
        // 'instanceTypes' can be configured to set the desired EC2 instance type.
        instanceType: "t2.medium",
        // 'desiredCapacity' sets the number of desired worker nodes for the cluster.
        desiredCapacity: 2,
    },
});

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

// Instantiate a Helm Chart to deploy the 'rds-exporter' Helm chart.
// The 'k8s.helm.v3.Chart' resource uses the Helm CLI to deploy charts to Kubernetes.
const rdsExporterChart = new k8s.helm.v3.Chart("rds-exporter", {
    // Specify your Helm chart details.
    chart: "rds-exporter",
    version: "0.24.0", // Use the desired version of the rds-exporter chart.
    // 'fetchOpts' specify options for fetching the Helm chart.
    fetchOpts: { 
        // It's common for Helm charts to be hosted in a Helm repository.
        // You must specify the repository URL if it's not a stable chart included by default.
        repo: "https://your-helm-chart-repository.com", 
    },
    // 'values' is used to provide the configuration for the chart.
    values: {
        // For illustration, we're setting a dummy value.
        // You would include the actual values required for the 'rds-exporter' chart.
        serviceMonitor: {
            enabled: true,
            // Additional configuration values as needed by the rds-exporter Helm chart.
        },
    },
    // Use the kubeconfig provided by the EKS cluster.
    // This ensures Helm deploys the chart to our EKS cluster.
    transformations: [
        (obj: any) => {
            if (obj.metadata) {
                obj.metadata.namespace = "monitoring";
            }
        },
    ],
}, { provider: cluster.provider });

// It's a good practice to output endpoints and other important information
// about your Kubernetes cluster and deployed resources.
export const rdsExporterChartStatus = rdsExporterChart.status;
```

This program performs the following steps:

1. Imports the necessary Pulumi packages for working with EKS and Kubernetes resources.
2. Creates an EKS cluster named "my-cluster" with a specific Kubernetes version and a desired node group configuration.
3. Exports the kubeconfig, which is essential for `kubectl` and other Kubernetes tools to communicate with the cluster.
4. Deploys the `rds-exporter` Helm chart using Pulumi's Kubernetes provider integrated with Helm. You'll need to specify the chart name, version, the repository if it's not a default Helm chart, and any custom values that are necessary for your specific Helm chart deployment.

After running this program with `pulumi up`, you'll have an EKS cluster with the `rds-exporter` deployed.

To visualize changes and manage resources after the execution, Pulumi provides a [Pulumi Service](https://www.pulumi.com/docs/intro/pulumi-service/) that allows you to see the resources, their statuses, and facilitate team collaboration.