Deploy the hive-schema helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In order to deploy the `hive-schema` Helm chart on an Amazon Web Services (AWS) Elastic Kubernetes Service (EKS) cluster, you will need to carry out the following steps:

1. Provision an EKS cluster.
2. Install and configure `kubectl` and `helm` with the necessary access to this cluster.
3. Deploy the `hive-schema` Helm chart to the EKS cluster.

Below is a Pulumi program written in TypeScript that sets up these resources. I’ll guide you through each step.

### Provisioning an AWS EKS Cluster

The `eks` package provides a high-level component that encapsulates the creation of an EKS cluster. We're using this to create our Kubernetes cluster in AWS. This abstracts away many of the lower level details that you would normally have to specify using the AWS provider directly.

The EKS cluster will have a default node group attached to it, which represents the EKS worker nodes. These are the EC2 instances that run your Kubernetes workloads.

### Installing Helm and Deploying the `hive-schema` Helm Chart

Once the EKS cluster is ready, you can interact with it using `kubectl`, the Kubernetes command-line tool. Before you can deploy the `hive-schema` Helm chart, you will need Helm installed locally or on a build server. Helm is a package manager for Kubernetes that enables defining, installing, and upgrading applications using a Helm chart.

In our Pulumi program, we use `kubernetes.helm.v3.Chart` resource which represents a Helm chart in a Pulumi program. The Helm chart is configured to deploy on the EKS cluster we've created.

### The Pulumi TypeScript Program

Here is your Pulumi program:

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

// Create an EKS cluster with the default configurations.
const cluster = new eks.Cluster("my-cluster", {});

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

// Set up a provider to use the kubeconfig for the created cluster.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Use the Helm Chart resource from the Pulumi Kubernetes package to
// deploy the `hive-schema` chart. The `repositoryOpts` would need to
// include the correct repository where the `hive-schema` chart is located,
// and `chart` should be the name of the chart in the repository.
// In our case, we assume `hive-schema` exists in a chart repository.
const chart = new k8s.helm.v3.Chart("hive-schema", {
    chart: "hive-schema",
    // Uncomment and specify the repository details if your Helm chart is hosted in a repository.
    // repo: "https://my-helm-chart-repository.example.com/",
    version: "1.0.0", // Replace with the version of the chart you want to deploy.
    // Uncomment and edit with appropriate values as needed for chart values.
    // values: {
    //     serviceType: "LoadBalancer", // Example value, replace as needed.
    // },
}, { provider });

// Export the public endpoint of the hive service.
export const hiveEndpoint = pulumi
    .all([chart.getResourceProperty("v1/Service", "hive-schema", "status"), chart.urn])
    .apply(([status, _]) => {
        const ingress = status.loadBalancer?.ingress[0];
        if (!ingress) {
            throw new Error('ingress is not set for the LoadBalancer');
        }
        if (ingress.ip) {
            return ingress.ip;
        }
        if (ingress.hostname) {
            return ingress.hostname;
        }
        throw new Error('unexpected status of the LoadBalancer');
    });
```
### Understanding the Program

- **Cluster Creation**: The cluster is created with default settings, which will be sufficient for many use cases and includes a default node group (set of worker nodes).

- **Kubeconfig Export**: The `kubeconfig` output from the cluster is how you configure `kubectl` and Helm to point to the correct EKS cluster.

- **Provider Setup**: The `provider` resource is how you tell Pulumi to use the kubeconfig for all following Kubernetes resources.

- **Helm Chart Deployment**: The `Chart` resource is how you install the Helm chart on your Kubernetes cluster. You need to provide the chart name and repository information.

- **Service Endpoint Export**: The hive service endpoint is extracted from the Kubernetes `Service` status once the Helm chart is deployed. This assumes your service type is using an external LoadBalancer; if not, you would retrieve the endpoint in a way that aligns with your service type.

### Next Steps

You will need to have Pulumi installed and configured, and your AWS credentials set up. Once that's ready, you can run `pulumi up` to provision your EKS cluster and deploy the `hive-schema`. After the deployment, Pulumi will display the exported `kubeconfig` and `hiveEndpoint` outputs.

If the Helm chart `hive-schema` is in a private repository or requires specific configurations, you will need to adjust the Helm chart block to include the `repo` and `values` keys as appropriate.

Please remember that this code will provision real cloud resources and incur costs. Review the pulumi.com documentation for details on each resource and service.

Deploy the hive-schema helm chart on AWS EKS

Provisioning an AWS EKS Cluster

Installing Helm and Deploying the hive-schema Helm Chart

The Pulumi TypeScript Program

Understanding the Program

Next Steps

Installing Helm and Deploying the `hive-schema` Helm Chart