Deploy the services-kafka helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `services-kafka` Helm chart on AWS EKS using Pulumi, you will need to follow these steps:

1. **Set up an EKS Cluster**: Deploy an Elastic Kubernetes Service (EKS) cluster on AWS. EKS is a managed Kubernetes service that simplifies the process of running Kubernetes on AWS without needing to install, operate, and maintain your own Kubernetes control plane or nodes.

2. **Configure the Kubernetes Provider**: You'll need to set up the Kubernetes provider to interact with your EKS cluster. Pulumi will use the kubeconfig from the created EKS cluster to communicate with it.

3. **Deploy the Helm Chart**: After setting up your EKS cluster, you can then deploy the `services-kafka` Helm chart to the cluster. Helm helps you manage Kubernetes applications and Helm charts help you define, install, and upgrade even the most complex Kubernetes application.

Below is a Pulumi program written in TypeScript that demonstrates these steps:

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

// Create an EKS cluster
const cluster = new eks.Cluster("my-kafka-cluster", {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    instanceType: "t2.medium",
    providerCredentialOpts: {
        profileName: "aws-profile", // specify your AWS profile name
    },
});

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

// Create a Kubernetes provider with the cluster's kubeconfig
const provider = new k8s.Provider("provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the services-kafka helm chart
const kafkaChart = new k8s.helm.v3.Chart("services-kafka", {
    chart: "services-kafka",
    version: "x.y.z", // specify chart version
    fetchOpts: {
        repo: "http://your-helm-chart-repository/", // specify Helm chart repository URL
    },
}, { provider });

// Export the Kafka service endpoint
export const kafkaEndpoint = kafkaChart.getResourceProperty(
    "v1/Service", "services-kafka", "status"
).apply(status => status.loadBalancer.ingress[0].hostname || status.loadBalancer.ingress[0].ip);
```

### Explanation
In the code above:

- We create an EKS cluster using the `eks.Cluster` class.

- We then export the generated kubeconfig needed to communicate with the Kubernetes cluster.

- We instantiate a Kubernetes provider, configuring it with our EKS cluster's kubeconfig.

- Finally, we deploy a Helm chart named `services-kafka` using the `k8s.helm.v3.Chart` resource. The `repo` value in `fetchOpts` should point to the Helm chart repository that hosts `services-kafka`.

- We export the Kafka service endpoint where you can access your Kafka deployment.

### Notes
- Replace `"x.y.z"` with the correct version of the `services-kafka` Helm chart that you wish to deploy.

- Replace `"http://your-helm-chart-repository/"` with the URL to the actual Helm chart repository where `services-kafka` is hosted.

- If your Helm chart repository is private, you may also need to supply additional `fetchOpts` such as `username` and `password`, or configure the repository access ahead of time.

- The `providerCredentialOpts` is configured with a profile name to specify which AWS credentials to use. Alternatively, you can configure your AWS credentials in the environment where Pulumi runs.

After setting this up, you can deploy the infrastructure using `pulumi up`. The Kafka service endpoint will be outputted by Pulumi after the deployment is successful, indicating where you can interact with your Kafka deployment.