Deploy the voltha-go-controller helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `voltha-go-controller` helm chart on AWS EKS, we'll need to follow a sequence of steps:

1. **Create an EKS cluster**: We'll start by provisioning an Amazon EKS cluster, which is a managed Kubernetes service that simplifies running Kubernetes on AWS without requiring the installation and operation of a separate Kubernetes control plane.

2. **Set up node groups for the EKS cluster**: Node groups are collections of EC2 instances that serve as worker nodes for the EKS cluster. These nodes run the actual workloads.

3. **Deploy the helm chart to the EKS cluster**: Helm charts are packages of pre-configured Kubernetes resources. We will use Pulumi's Kubernetes provider to deploy the `voltha-go-controller` chart to our EKS cluster.

We'll use the `@pulumi/eks` library to create the cluster and node groups, as it provides a Pulumi component that encapsulates much of the complexity, and the `@pulumi/kubernetes` library to deploy the helm chart.

Below is a detailed Pulumi TypeScript program that accomplishes the deployment of a `voltha-go-controller` helm chart on AWS EKS:

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

// Step 1: Create an AWS EKS cluster
// Documentation: https://www.pulumi.com/registry/packages/eks/api-docs/cluster/
const cluster = new eks.Cluster("voltha-cluster", {
    version: "1.22", // specify the desired Kubernetes version, change as per your requirements
    instanceType: "t2.medium", // specify the desired EC2 instance type for the worker nodes
    desiredCapacity: 2, // desired number of worker nodes
    minSize: 1, // minimum number of worker nodes
    maxSize: 3, // maximum number of worker nodes
});

// Step 2: (Optional) If your Helm chart depends on a custom IAM role, create it here
// You might need a custom IAM role for certain Kubernetes workloads, such as for pods that need access to AWS resources
// Check the documentation of the voltha-go-controller for any specific IAM permissions required

// Step 3: Deploy the voltha-go-controller helm chart
// Using the Helm Chart resource from the Pulumi Kubernetes provider
// Documentation: https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm.sh/v3/chart/
const volthaChart = new k8s.helm.v3.Chart("voltha-go-controller", {
    chart: "voltha-go-controller",
    version: "1.0.0", // use the appropriate chart version
    fetchOpts: {
        repo: "http://chart-repository-url/", // specify the helm chart repository URL
    },
    namespace: "default", // specify the namespace you want to deploy into, create if not exists
}, { provider: cluster.provider });

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

// Optionally, you can export other outputs such as cluster endpoint and a Helm chart status
export const clusterEndpoint = cluster.core.endpoint;
export const volthaChartStatus = volthaChart.status;
```

This program first sets up an EKS cluster and then uses the Helm Chart resource to deploy the `voltha-go-controller`. You should replace `"http://chart-repository-url/"` with the actual Helm chart repository where the `voltha-go-controller` is hosted.

You will need to have Pulumi, AWS CLI, and `kubectl` installed and set up on your system to use this script. Once they are set up and you have the appropriate permissions configured for AWS, you can run `pulumi up` to execute this Pulumi program.

Ensure you review the `voltha-go-controller` helm chart for any prerequisites or dependencies that might be needed for a successful deployment, like specific IAM roles and permissions or additional Kubernetes configuration.