Deploy the grafana-dashboards-rancher helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Grafana dashboards Rancher helm chart on AWS EKS, we need to follow a series of steps to set up the EKS cluster and configure the helm release. Pulumi has extensive support for AWS services, and the `@pulumi/awsx`, `@pulumi/aws`, and `@pulumi/kubernetes` libraries make it straightforward to accomplish this.

Here's how you can do it with Pulumi in TypeScript:

1. **Set up an EKS cluster**: We will create an EKS cluster using Pulumi’s `awsx` library, which provides higher-level abstractions that simplify EKS cluster creation.

2. **Define IAM Roles**: We’ll define the necessary IAM roles for the EKS cluster nodes. EKS requires specific roles that provide the necessary AWS permissions for cluster operation.

3. **Create a Node Group**: We'll set up a node group for our EKS cluster. Node groups are groups of worker nodes that run your applications.

4. **Deploy Helm Chart**: Once the EKS cluster is up and running, we will use `@pulumi/kubernetes` library to deploy the Grafana dashboards Rancher helm chart to the EKS cluster.

Here’s a Pulumi program in TypeScript that captures these steps:

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

// Create an EKS cluster with default settings.
const cluster = new eks.Cluster("my-cluster");

// Create a Kubernetes provider instance that uses our EKS cluster from above.
const k8sProvider = new k8s.Provider("eks-k8s", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the Grafana dashboards Rancher helm chart.
const grafanaDashboard = new k8s.helm.v3.Chart("grafana-dashboards-rancher", {
    chart: "grafana",
    fetchOpts: {
        // Specify the Helm repository where the Grafana chart is located.
        repo: "https://grafana.github.io/helm-charts",
    },
    version: "6.13.3", // This should be the version of the Helm chart you wish to deploy.
    namespace: "default", // Assuming you want to deploy to the 'default' namespace.
    // Values here are example configurations. Please change them to suit your needs.
    values: {
        service: {
            type: "LoadBalancer",
        },
        dashboardProviders: {
            dashboardproviders: yamlConfigString,
        },
        dashboards: {
            mydashboard: {
                gnetId: 7362,
                revision: 5,
                datasource: "prometheus",
            },
        },
    },
}, { providers: { kubernetes: k8sProvider } });

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

In this program:

- We create an `eks.Cluster` to represent the EKS cluster, which by default sets up the required resources with default configurations.
- We create a Kubernetes provider that uses the EKS cluster as the target environment for subsequent deployments.
- We then declare a new Helm chart resource, the `grafana-dashboards-rancher`, and specify the necessary settings and values.
  - You must replace `yamlConfigString` with your actual dashboard provider configuration YAML.
  - Configure the `service` type as `LoadBalancer` to make the Grafana service accessible over the internet (adjust this according to your security requirements).
  - We set the `gnetId` and `revision` to match the Rancher Grafana dashboard you want to import.
- Finally, we export the kubeconfig of the cluster which can be used to access the EKS cluster with `kubectl`.

Remember, you'll need to modify the settings under `values` to match the specific Grafana dashboard configurations you want to deploy.

Once the program is ready, run the following commands to deploy your infrastructure:

```bash
pulumi up
```

This command initiates the Pulumi deployment, which will set up the EKS cluster and deploy the Grafana dashboards. Pulumi provides detailed output in the terminal, giving you visibility into the actions it performs.