Deploy the appmesh-prometheus helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `appmesh-prometheus` Helm chart on AWS EKS, you will need to perform the following steps:

1. **Create an EKS Cluster**: You will create an EKS cluster using Pulumi's `aws.eks.Cluster` resource. The EKS cluster is where your Kubernetes workloads will run.
   
2. **Set Up AWS App Mesh**: App Mesh is a service mesh that provides application-level networking. It makes it easy to monitor and control microservices running on AWS.

3. **Deploy the Helm Chart**: Once EKS is running and App Mesh is configured, you can deploy the `appmesh-prometheus` Helm chart using Pulumi's `kubernetes.helm.v3.Chart` resource.

Below is a detailed Pulumi program in TypeScript that performs these steps. This program assumes you already have Pulumi installed and configured with the necessary AWS credentials.

```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";

// Step 1: Create an EKS Cluster
// Documentation: https://www.pulumi.com/registry/packages/aws/api-docs/eks/cluster/

// Create the EKS cluster and a default node pool.
const cluster = new eks.Cluster("my-eks-cluster", {
    // Specify desired settings for the cluster
});

const kubeconfig = cluster.kubeconfig.apply(JSON.stringify);

// Step 2: Set Up AWS App Mesh
// Documentation: https://www.pulumi.com/registry/packages/aws/api-docs/appmesh/mesh/

const mesh = new aws.appmesh.Mesh("my-mesh", {
    // Configuration properties for the App Mesh
    spec: {
        egressFilter: {
            type: "ALLOW_ALL",
        },
    },
});

// Step 3: Deploy the appmesh-prometheus Helm chart
// Documentation: https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm.sh/v3/chart/

// Create a Kubernetes provider instance that uses our EKS cluster.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Use the Helm chart to deploy appmesh-prometheus.
const appmeshPrometheusChart = new k8s.helm.v3.Chart("appmesh-prometheus-chart", {
    chart: "appmesh-prometheus",
    version: "1.0.0", // Specify the chart version if necessary
    fetchOpts: {
        repo: "https://repo-url-to-the-appmesh-prometheus/", // Replace with the correct Helm repo URL
    },
}, { provider: provider });

// Export the cluster's kubeconfig and the service endpoint of the Prometheus server
export const kubeconfigOutput = kubeconfig;
export const prometheusEndpoint = appmeshPrometheusChart.getResourceProperty("v1/Service", "appmesh-prometheus-server", "status").apply(status => status.loadBalancer.ingress[0].hostname);
```

In this program:

- The `eks.Cluster` resource creates a new EKS cluster.
- AWS App Mesh is set up with a `aws.appmesh.Mesh` resource. The `spec` section defines the configuration for the mesh; in this case, it allows all egress traffic.
- The `kubernetes.helm.v3.Chart` resource is responsible for deploying the Helm chart. It references the chart name (`appmesh-prometheus`) and the version, as well as specifies the repository URL where the chart can be found.

Before running this code, ensure the Helm repository containing the `appmesh-prometheus` chart is correctly specified. Replace `"https://repo-url-to-the-appmesh-prometheus/"` with the actual repository URL.

If you are not familiar with Pulumi and the cloud resources, here's what they're used for:

- **Pulumi**: It's an infrastructure as code tool that lets you create, deploy, and manage infrastructure using code written in general-purpose programming languages.
- **AWS EKS (Elastic Kubernetes Service)**: A managed Kubernetes service provided by AWS to easily run Kubernetes on AWS without needing to install and operate your own Kubernetes control plane or nodes.
- **AWS App Mesh**: A service mesh that provides application-level networking to standardize how your services communicate, providing end-to-end visibility and ensuring high-availability for your applications.
- **Helm Chart**: Helm is a package manager for Kubernetes and Charts are packages of pre-configured Kubernetes resources.

To deploy this infrastructure, run the `pulumi up` command from your terminal in the directory where this Pulumi program is saved. Pulumi will perform the deployment, and you can watch the progress in your terminal. Once completed, Pulumi will output any exported values, such as the Prometheus endpoint.