Deploy the k8s-node-image-1-18 helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `k8s-node-image-1-18` Helm chart on AWS EKS using Pulumi, you'll need to create an EKS cluster and then deploy the Helm chart onto it.

Firstly, you'll need to set up an EKS cluster. The `eks.Cluster` resource is a high-level component that provisions an EKS cluster and its associated resources, like IAM roles and security groups. To create the cluster, you'll specify various parameters, such as the desired Kubernetes version, the size of the node group, and the instance types for the worker nodes.

Once the EKS cluster is provisioned, you can deploy the Helm chart to it. The `kubernetes.helm.v3.Chart` resource from the `@pulumi/kubernetes` package allows you to deploy a Helm chart. By providing the name of the chart and the repository it's located in, Pulumi will manage the deployment of the chart to your cluster, similar to how you would use the Helm CLI.

Below is a Pulumi program written in TypeScript that uses these resources to accomplish this task:

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

// Create an EKS cluster with the default configuration.
// This will create a default node group, and configure the required network and IAM settings for the cluster.
const cluster = new eks.Cluster("my-cluster", {
    version: "1.18", // specify the Kubernetes version for the EKS cluster
    instanceType: "t2.medium", // specify the EC2 instance type for the nodes
    desiredCapacity: 2, // specify the desired number of nodes
    minSize: 1, // specify the minimum number of nodes
    maxSize: 3, // specify the maximum number of nodes
});

// Once the cluster is created, we'll need a way to communicate with it.
// Pulumi provides a kubeconfig that we can use with kubectl or any Kubernetes client library.
const kubeconfig = cluster.kubeconfig.apply(JSON.stringify);

// Create a provider to handle the deployment of the Helm chart to our EKS cluster.
// The provider uses the kubeconfig from our cluster, giving it access to deploy resources.
const provider = new k8s.Provider("provider", {
    kubeconfig: kubeconfig,
});

// Deploy the `k8s-node-image-1-18` Helm chart into the EKS cluster.
// The chart name and version are placeholders and should be replaced with actual values if available.
const chart = new k8s.helm.v3.Chart("my-chart", {
    chart: "k8s-node-image-1-18", // specify the name of the Helm chart
    // You must specify the repository where the chart is located using the `repo` property.
    // For example, `repo: "http://example.com/charts"`. This is a placeholder and should be updated.
    version: "1.18", // specify the chart version, if required
}, { provider }); // Make sure to associate the Helm chart deployment with the EKS provider we set up earlier

// Export the cluster's kubeconfig and the Helm chart's metadata.
export const kubeconfigOutput = kubeconfig;
export const chartResources = chart.resources;
```

Make sure to replace the placeholders for the chart name, version, and repository with the actual values for your Helm chart. The program above is quite simplified—configuring an EKS cluster often involves a lot of other considerations like VPC configurations, IAM roles, and security group settings. The example assumes defaults that may not be suitable for production scenarios.

To use this program, save it as `index.ts` in a new Pulumi project directory. Then, run `pulumi up` from that directory. Pulumi will perform the deployment, which includes setting up the AWS EKS cluster and deploying the Helm chart to it.

Note that you must have AWS credentials configured in your environment for Pulumi to communicate with AWS. Additionally, you need to have Pulumi installed and set up.