Deploy the calico-aws helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Calico-AWS Helm chart on an AWS EKS cluster using Pulumi, you would typically follow these steps:

1. **Set up an EKS cluster**: You need an EKS cluster running on AWS. You can either use an existing one or create a new one using Pulumi.

2. **Install the Helm Chart**: Once you have your EKS cluster, you will use Pulumi's integration with Kubernetes to deploy the Calico Helm chart.

Below is a program written in TypeScript that outlines these steps using Pulumi. Make sure you have installed the necessary Pulumi packages for AWS (`@pulumi/aws` and `@pulumi/eks`) and Kubernetes (`@pulumi/kubernetes`). This program assumes you have Pulumi and AWS CLI configured with the appropriate 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";

// Create an EKS cluster.
const vpc = new aws.ec2.Vpc("vpc", {
  cidrBlock: "10.100.0.0/16",
});

const subnet = new aws.ec2.Subnet("subnet", {
  vpcId: vpc.id,
  cidrBlock: "10.100.1.0/24",
  availabilityZone: "us-west-2a",
});

const cluster = new eks.Cluster("cluster", {
  vpcId: vpc.id,
  subnetIds: [subnet.id],
  instanceType: "t2.medium",
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 2,
  storageClasses: "gp2",
  deployDashboard: false,
});

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

// Deploy the Calico Helm chart to the EKS cluster.
const calicoChart = new k8s.helm.v3.Chart("calico", {
  chart: "calico",
  version: "0.3.0", // Specify the version of the chart if required.
  fetchOpts: {
    repo: "https://docs.projectcalico.org/charts", // The Helm repository where the calico chart is hosted.
  },
}, {provider: k8sProvider});

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

Here's what this program does:

1. We start by importing the required Pulumi modules.
2. A new VPC and subnet are created specifically for the EKS Cluster. You may use existing ones if you have them.
3. The `eks.Cluster` class is used to create a new Amazon EKS cluster. It's configured with a set of nodes that fall within the `t2.medium` instance type, and an initial desired capacity of 2 nodes. You may adjust these according to your needs.
4. With our EKS cluster set up, we create a Kubernetes provider using the kubeconfig of the cluster. This allows Pulumi to communicate with our EKS cluster.
5. The `k8s.helm.v3.Chart` resource is then used to deploy the Calico Helm chart to the EKS cluster. You may have to specify the chart version that matches your requirements. The repository URL provided is the location of the Calico Helm charts.

The `kubeconfig` and the `clusterEndpoint` are exported from the program. They can be used to interact with the EKS cluster from your local machine using `kubectl`.

Remember to run `pulumi up` to create and deploy resources. If you need to adjust the number of nodes or machine types, you can modify this program accordingly.