Deploy the gloo-mesh helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Gloo Mesh Helm chart on AWS Elastic Kubernetes Service (EKS), you need to go through several steps:

1. **Create an EKS cluster**: This will be the Kubernetes cluster where you deploy Gloo Mesh.
2. **Configure `kubectl`**: Set up `kubectl` to interact with the new EKS cluster.
3. **Install the Helm chart**: Using Pulumi's Kubernetes provider to deploy the Gloo Mesh Helm chart onto your EKS cluster.

I'll now guide you through a Pulumi program in TypeScript that accomplishes these tasks. Along the way, I'll explain each step and the resources being used.

First, make sure you have the AWS and Kubernetes Pulumi providers installed:

```bash
$ npm install @pulumi/aws @pulumi/eks @pulumi/kubernetes
```

Here's a Pulumi TypeScript program to set up an EKS cluster and deploy the Gloo Mesh Helm chart:

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

// Step 1: Creating the EKS cluster
// The EKS cluster will be the environment where the Gloo Mesh Helm chart is deployed.
const cluster = new eks.Cluster('eks-cluster', {
    // Define your EKS cluster options here.
    // Example: VPC ID, subnet IDs, node size, desired capacity, and so on.
    // For more options see: https://www.pulumi.com/registry/packages/eks/api-docs/cluster/
});

// Export the cluster's kubeconfig and name to be used by `kubectl` and Helm
export const kubeconfig = cluster.kubeconfig;
export const clusterName = cluster.eksCluster.name;

// Step 2: Set up kubectl
// Here we're going to set up the Kubernetes provider to use the `kubeconfig`
// we get from our EKS cluster which allows us to interact with our Kubernetes cluster.
const provider = new k8s.Provider('k8s-provider', {
    kubeconfig: cluster.kubeconfig,
});

// Step 3: Deploying the Gloo Mesh Helm chart
// The provided Helm chart installation will install Gloo Mesh in the
// Kubernetes cluster with the basic configuration.
// You will need to specify the `chart`, `version` and `namespace` accordingly.
const glooMeshChart = new k8s.helm.v3.Chart('gloo-mesh', {
    chart: 'gloo-mesh',
    version: '1.1.0', // Replace with the actual chart version you want to deploy
    namespace: 'gloo-system', // Replace with the namespace where you want to install Gloo Mesh
    // If there's a need to specify values to customize the Helm chart, you can use `values`.
    // Example:
    // values: {
    //     // Helm chart values go here.
    // },
}, { provider });

// Optionally, you can export relevant data such as the Helm release status or the namespace.
export const glooMeshStatus = glooMeshChart.status;
export const glooMeshNamespace = glooMeshChart.namespace;
```

In this program:

- We create an EKS cluster using the `eks.Cluster` class.
- We set up a Kubernetes provider with the `kubeconfig` output from our EKS cluster.
- We deploy the Gloo Mesh Helm chart using the Pulumi `Chart` class from the `@pulumi/kubernetes` package.

Please ensure you have Helm and `kubectl` installed locally and have the necessary AWS IAM permissions to create EKS clusters.

To run the Pulumi program, use:

```bash
$ pulumi up
```

This command will show you a preview of the resources that Pulumi will create for deploying the Gloo Mesh Helm chart on EKS. If everything looks good, select `yes` to proceed with the deployment.

Remember to replace `'1.1.0'` with the actual version of the Gloo Mesh Helm chart you wish to deploy and to specify the namespace if it's different from `'gloo-system'`.

After the deployment, you can use the exported `kubeconfig` to manage your EKS cluster and Gloo Mesh installation with `kubectl`.