Deploy the eck-resource helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `eck-resource` Helm chart on AWS EKS using Pulumi, we will go through several steps to ensure you have a fully functional Kubernetes cluster managed by Amazon EKS and then deploy the Elastic Cloud on Kubernetes (ECK) Helm chart.

Here's a breakdown of the steps involved:

1. **Set up an EKS Cluster**: We will need an EKS cluster to run our Kubernetes applications. We'll define an EKS cluster resource using the higher-level `eks.Cluster` resource from the `@pulumi/eks` package, which simplifies the creation of an EKS cluster.

2. **Define an ECR Repository (Optional)**: Although not explicitly requested, if the `eck-resource` Helm chart requires a private image from AWS Elastic Container Registry (ECR), we'll need an ECR repository. We can define this using the `aws.ecr.Repository` resource from the `@pulumi/aws` package.

3. **Deploy Helm Chart on EKS**: To deploy the `eck-resource` Helm chart, we'll use the `kubernetes.helm.v3.Chart` resource from the `@pulumi/kubernetes` package. This resource allows us to deploy a Helm chart into a Kubernetes cluster.

Let's proceed with the Pulumi TypeScript program to accomplish the above steps. Below is a detailed explanation along with the code:

```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: Creating the Amazon EKS cluster.
const cluster = new eks.Cluster("eks-cluster", {
    // Allocating the minimum size for the EKS cluster for demonstration purposes.
    // You might want to choose more suitable sizing for production use.
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    // Deploying the default node group in the default VPC and default subnets.
    // Specifying the version of Kubernetes you want to deploy.
    version: "1.21",
});

// Outputs the kubeconfig to connect to the created EKS cluster
export const kubeconfig = cluster.kubeconfig;

// Step 2: Deploying the eck-resource Helm chart.
const eckChart = new k8s.helm.v3.Chart("eck-resource", {
    chart: "eck",
    version: "1.0.0", // Use the correct version for the eck Helm Chart
    fetchOpts: {
        repo: "https://helm.elastic.co/",
    },
}, { provider: cluster.provider });

// Step 3: (Optional) If your Helm chart requires images from ECR, set up the repository.
const ecrRepository = new aws.ecr.Repository("ecr-repository", {
    imageTagMutability: "MUTABLE",
    imageScanningConfiguration: {
        scanOnPush: true,
    },
});

// Output the ECR repository URL
export const repositoryUrl = ecrRepository.repositoryUrl;

```

### Explanation:

- **EKS Cluster**: The `eks.Cluster` resource is a high-level component that encapsulates the configuration needed to create a fully-managed EKS cluster. In the example above, we create a cluster with a default node group with a specified number of instances.

- **Kubeconfig Output**: We output the generated kubeconfig which can be used to interact with your cluster using tools like `kubectl`.

- **ECR Repository (Optional)**: An ECR repository is defined if you have private container images required by the Helm chart. This is optional and can be omitted if not needed.

- **Helm Chart**: We deploy the `eck-resource` Helm chart to the EKS cluster using Pulumi's Helm chart component. You must replace `"1.0.0"` with the version of the `eck` chart you intend to deploy, and ensure the `repo` points to the correct Helm repository provided by Elastic.

Please replace the values with the appropriate versions and configurations for your specific use case. It's important to make sure that your Pulumi AWS provider and the AWS CLI are configured with the necessary permissions and settings to create these resources.

Keep in mind that the EKS cluster could incur costs in your AWS account, and running a Kubernetes cluster comes with its own associated costs. Always check the AWS pricing page to understand the costs associated with the EKS service and underlying EC2 instances.