Deploy the elastic-packetbeat helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `elastic-packetbeat` Helm chart on AWS Elastic Kubernetes Service (EKS), we will first need to create an EKS Cluster using the Pulumi AWS EKS module. Once the cluster is set up, we will use the Pulumi Kubernetes provider to install the `elastic-packetbeat` Helm chart.

Here's a step-by-step guide and the corresponding Pulumi program to achieve this:

1. **Set up an EKS cluster**: We will create an EKS cluster using the high-level `eks.Cluster` resource from the Pulumi EKS package. This package simplifies creating EKS clusters and node groups. The cluster will be the Kubernetes environment where Packetbeat will be deployed.

2. **Create a node group**: In the EKS cluster, we will define a node group. This is a collection of EC2 instances that will be registered as nodes in the Kubernetes cluster.

3. **Install Packetbeat using Helm**: Once the cluster is provisioned and active, we will use the Pulumi Kubernetes provider to deploy the `elastic-packetbeat` Helm chart. The `kubernetes.helm.v3.Chart` resource will be used to deploy the chart to the cluster.

Let's proceed with the Pulumi TypeScript program:

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

const name = "packetbeat-cluster";

// Create an EKS cluster.
const cluster = new eks.Cluster(name, {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    // Alternatively, we can specify an existing VPC or subnet IDs.
});

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

// Create a Kubernetes provider instance that uses our EKS cluster.
const provider = new kubernetes.Provider(name, { kubeconfig: cluster.kubeconfig });

// Deploy the elastic-packetbeat Helm chart to the EKS cluster.
const elasticPacketbeatChart = new kubernetes.helm.v3.Chart("elastic-packetbeat", {
    chart: "packetbeat",
    // Replace with the repository that hosts the packetbeat chart
    // e.g., repo: "https://helm.elastic.co"
    version: "7.10.0", // The version number of Packetbeat
    namespace: "kube-system", // Deploy in the 'kube-system' namespace
}, { provider });

// Export the Packetbeat service URL by querying the Kubernetes resources.
export const packetbeatService = elasticPacketbeatChart.getResourceProperty("v1/Service", "kube-system", "elastic-packetbeat-packetbeat", "status").apply(status => status.loadBalancer.ingress[0].hostname);
```

Explanation:

- `eks.Cluster`: This resource is used to provision an EKS Cluster. We specify the instance type, desired capacity, minimum size, and maximum size for the nodes.
  
- `kubeconfig`: We export the kubeconfig of the EKS cluster so that we can interact with the cluster using `kubectl` or other Kubernetes tooling.

- `kubernetes.Provider`: This creates a Pulumi Kubernetes provider that will allow us to deploy Kubernetes resources on the EKS cluster.

- `kubernetes.helm.v3.Chart`: This resource is responsible for installing a Helm chart into the Kubernetes cluster. We define the chart name (`packetbeat`), version, and namespace.
  
- `packetbeatService`: We export the URL of the Packetbeat service so you can interact with it.

Please note that we have pointed out where you may need to replace values such as the Helm repository URL and version number with the actual values corresponding to the elastic-packetbeat chart you wish to deploy. Before running the program, ensure that you have the Pulumi CLI installed and configured as well as the required AWS credentials set up.