Deploy the python-webapp helm chart on AWS EKS

Question

Pulumi · Accepted Answer

Deploying a Helm chart to an Amazon EKS (Elastic Kubernetes Service) cluster involves several steps. Firstly, you need to provision an EKS cluster, and then you can deploy your Helm chart to it.

In this Pulumi program, I'll guide you through setting up an AWS EKS cluster and deploying a Helm chart which contains the Python web application. We'll use Pulumi's EKS package for creating the cluster and the Kubernetes package for deploying the Helm chart.

### Step 1: Define the EKS Cluster
We'll start by creating an EKS cluster. An EKS cluster provides the Kubernetes control plane, and Pulumi's EKS package simplifies its instantiation. The `eks.Cluster` resource creates a new EKS cluster along with the related AWS resources like EC2 instances for worker nodes.

### Step 2: Deploying the Helm Chart
Once the cluster is up, we'll deploy the Helm chart for the Python web app using the `Chart` resource from Pulumi's Kubernetes package. The `Chart` resource represents a Helm chart in a Pulumi program and can be used to deploy applications.

Let's look at the Pulumi TypeScript program to achieve this.

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

// Step 1: Create the EKS cluster
const cluster = new eks.Cluster("my-eks-cluster", {
    // Define the number and type of nodes in the node group.
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    instanceType: "t2.medium",
});

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

// Step 2: Deploy the Python web app Helm chart to the EKS cluster
// Define the Helm chart values.
const chartValues = {
    service: {
        type: "LoadBalancer",
    }
};

// Create a new Helm chart instance, providing the chart name, and values
const webAppChart = new k8s.helm.v3.Chart("python-webapp", {
    chart: "python-webapp",
    version: "1.0.0",  // specify the version of the chart you want to deploy
    fetchOpts: { repo: "http://charts.example.com/" }, // provide the Helm repo URL here
    values: chartValues,
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeconfig }) });

// Export the endpoint to access the web app.
export const webAppEndpoint = webAppChart.getResourceProperty("v1/Service", "python-webapp", "status")
    .apply(status => status.loadBalancer.ingress[0].hostname || status.loadBalancer.ingress[0].ip);
```

In this program:

- We initialize a new EKS cluster with the `eks.Cluster` class. The `desiredCapacity`, `minSize`, and `maxSize` parameters control the scaling of your worker node group within the cluster, and `instanceType` specifies the type of EC2 instance used for the worker nodes.
  
- The kubeconfig needed to interact with the cluster from outside is exported using `export const kubeconfig`.

- We then define a `Chart` resource named `python-webapp` which represents the Helm deployment of the Python web application. The `chart` parameter specifies the name of the chart, and `version` is the version number of the chart. The `fetchOpts` parameter contains the repository URL where the Helm chart is located.

- We specify custom values for the Helm chart using the `values` property. Here, we configure the Kubernetes Service of type `LoadBalancer` which will expose the Python web app to the internet. Update the `repo` URL with the actual Helm repository you are using.

- The provider used for Helm chart deployment is explicitly set using the EKS cluster's kubeconfig to ensure that Helm interacts with the right cluster.

- Finally, we export `webAppEndpoint` which will contain the endpoint to access the deployed web app once the service is up and running. The load balancer ingress hostname or IP is obtained from the service's status.

Run this Pulumi program in the directory where your Pulumi project is initialized by executing `pulumi up`. This will provision the EKS cluster and deploy your Helm chart.

Remember to replace the chart information (`python-webapp`, `version`, and the `repo` URL) with actual values based on the Helm chart you are deploying.