Deploy the simple-grafana helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy the `simple-grafana` Helm chart on AWS Elastic Kubernetes Service (EKS), we’ll go through several steps:

1. **Setup an EKS Cluster**: We'll create an EKS cluster where our Grafana Helm chart will be deployed. This requires creating the necessary roles and VPC configuration.
   
2. **Create an ECR Repository** (optional): If you need to manage container images, you might optionally want to set up an Elastic Container Registry (ECR) repository. This, however, isn't directly required for deploying a standard Helm chart.
   
3. **Deploy the Helm Chart**: Once our Kubernetes cluster is ready, we will deploy the `simple-grafana` Helm chart to the EKS cluster.

I’ll provide a TypeScript program for Pulumi which you can use to deploy the `simple-grafana` Helm chart on an AWS EKS cluster. The program will include comments to explain the steps.

Let’s start building this out.

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

// Create an EKS cluster
const cluster = new eks.Cluster('my-eks-cluster', {
    version: '1.18', // Specify your desired Kubernetes version here
    instanceType: 't2.medium', // Specify your desired instance type here
    desiredCapacity: 2, // Specify the number of worker nodes
    minSize: 1,
    maxSize: 3,
});

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

// Deploy the simple-grafana Helm chart to the EKS cluster
const grafanaChart = new k8s.helm.v3.Chart('simple-grafana', {
    repo: 'grafana', // Ensure this is the correct Helm repo for simple-grafana
    chart: 'grafana',
    version: '6.1.9', // Specify your desired chart version here
    namespace: 'default', // Specify the namespace if you're not using the default one
}, { provider: cluster.provider });

// Export the Grafana service URL by querying the service object and finding its load balancer URL
export const grafanaUrl = grafanaChart.getResourceProperty('v1/Service', 'simple-grafana', 'status')
    .apply(status => status.loadBalancer.ingress[0].hostname);
```

This is the basic structure of how you could use Pulumi and TypeScript to create an EKS cluster and deploy the `simple-grafana` Helm chart onto it.

Here's what each piece of the code does:

- `eks.Cluster`: Provisions a new EKS cluster with the specified Kubernetes version, instance type, and scaling parameters.
  - The `version` is the desired Kubernetes version.
  - The `instanceType` is the AWS EC2 instance type for your worker nodes.
  - `desiredCapacity`, `minSize`, `maxSize` control the scaling of your worker nodes.
  - The `kubeconfig` output allows you to interact with your cluster using tools like `kubectl`.

- `k8s.helm.v3.Chart`: Deploys a Helm chart onto the Kubernetes cluster.
  - The `repo`, `chart`, and `version` parameters specify the details of the Helm chart you want to deploy.
  - Set `provider: cluster.provider` to ensure the Helm chart is installed on the newly created EKS cluster.

- `grafanaUrl`: Exports the URL on which Grafana can be reached after it has been deployed.

Make sure you have the Pulumi CLI installed and are logged in to the AWS console with appropriate permissions. You would run this script using the Pulumi CLI, and it would handle the creation and deployment of these resources for you.

Remember that deploying real infrastructure may incur costs in AWS. Always review the resources and understand the billing implications before deployment.