Deploy the canary-operator helm chart on AWS EKS

Question

Pulumi · Accepted Answer

Sure, deploying a Helm chart to an Amazon EKS cluster involves several steps. We'll be working with these main resources:

1. `eks.Cluster`: This creates an EKS cluster in your AWS account. An EKS cluster provides the Kubernetes control plane.
2. `kubernetes.helm.v3.Chart`: This Pulumi Kubernetes resource allows us to deploy a Helm chart into our Kubernetes cluster.

Firstly, we need to create an EKS cluster. Pulumi's EKS package provides a high-level interface over AWS EKS which simplifies the process. Once we have the cluster, we can use the Kubernetes provider from Pulumi to interact with our cluster and deploy the Helm chart. Below is the Pulumi program written in TypeScript which illustrates this process.

Please note that before you run this program:

- You must have Pulumi CLI installed and configured with AWS credentials.
- You need to have Helm CLI installed if you need to fetch values or inspect the chart locally.
- The AWS region should be set where your EKS cluster will be deployed (either using the AWS configuration or via the Pulumi config).
- The `canary-operator` Helm chart must be available in a Helm repository.

### Detailed Program Explanation

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

// Create an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    // Specify the desired capacity and instance types for the default node group.
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    instanceType: "t2.medium",  // Choose an instance type appropriate for your needs.
});

// Once the cluster is created, we can get its kubeconfig to interact with it.
const kubeconfig = cluster.kubeconfig.apply(JSON.stringify);

// Create a Kubernetes provider instance using the kubeconfig from the EKS cluster.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Now, let's deploy the "canary-operator" Helm chart.
const canaryChart = new k8s.helm.v3.Chart("canary-operator", {
    chart: "canary-operator",  // The name of the chart. Replace with the actual name if different.
    version: "0.1.0",  // Specify the version of the chart.
    namespace: "default",  // The namespace where you want to install the chart. You can change it as needed.
    fetchOpts: {
        repo: "https://canary-operator-helm-repo.com",  // The Helm chart repository where the chart is located.
    },
}, { provider: k8sProvider });

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

// Export the cluster endpoint to access it externally.
export const clusterEndpoint = cluster.endpoint;
```

This program will provision an EKS cluster and deploy the canary-operator Helm chart into the `default` namespace. You need to replace the values of `chart`, `version`, and `fetchOpts.repo` with the appropriate values for the canary-operator Helm chart. The `kubeconfigOutput` and `clusterEndpoint` are exported so you can interact with your cluster immediately after it's provisioned.

When you run the Pulumi program, it will perform the following sequence of operations:

1. Provision a new EKS cluster with the specified configuration.
2. Use the obtained kubeconfig to define a Pulumi Kubernetes provider.
3. Use the provider to deploy the canary-operator Helm chart from the specified repository into the EKS cluster.

Remember to run `pulumi up` after setting up your Pulumi program with the code above. This command begins the deployment process according to the code's definitions.