Deploy the api-graphql helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `api-graphql` Helm chart on AWS EKS using Pulumi, you'll first need to set up an EKS cluster and then deploy the Helm chart onto that cluster. Below is a detailed explanation of how to achieve this, followed by a Pulumi TypeScript program.

Firstly, you need to configure AWS and Kubernetes providers for Pulumi. After initializing your Pulumi project, you'll use the `@pulumi/aws` and `@pulumi/eks` packages to create an AWS EKS cluster. The AWS EKS cluster will be the Kubernetes cluster where your Helm chart will be deployed.

The `@pulumi/awsx` package can be effective for creating an EKS cluster with higher-level abstractions than those found in `@pulumi/aws`. It simplifies the provisioning and management of the associated networking infrastructure like VPCs and subnets.

Once the EKS cluster is up and running, you will configure the Pulumi Kubernetes provider to target this newly created EKS cluster. This step is important because Pulumi needs to communicate with the right cluster to deploy the Helm chart.

After setting up the Kubernetes provider, you'll use the `@pulumi/kubernetes` package to deploy the `api-graphql` Helm chart to the AWS EKS cluster. The `helm.v3.Chart` resource from this package allows you to supply the chart name, version, and any custom values you may need for the deployment.

Now, let's put this into a Pulumi program written in TypeScript.

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

// Create an EKS cluster.
const cluster = new eks.Cluster('eksCluster', {
  // EKS cluster options
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 2,
  // More cluster options as needed...
});

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

// Create a Kubernetes provider instance that uses the EKS cluster's kubeconfig.
const provider = new k8s.Provider('k8sProvider', {
  kubeconfig: cluster.kubeconfig,
});

// Deploy the `api-graphql` Helm chart.
const apiGraphqlChart = new k8s.helm.v3.Chart('api-graphql', {
  chart: 'api-graphql',
  // Specify the Helm repository here if not using a chart from the stable repository.
  // repo: 'my-helm-repo',
  version: '1.0.0', // Specify the chart version.
  // Any additional values needed for your api-graphql Helm chart can be added here.
  values: {
    service: {
      type: 'LoadBalancer',
    },
    // ...other configurations
  },
}, { provider }); // Make sure to associate the Kubernetes provider with the Helm chart.

// Export relevant resources
export const apiGraphqlEndpoint = apiGraphqlChart.getResourceProperty(
  'v1/Service', 'api-graphql', 'status'
).apply(status => status.loadBalancer.ingress[0]);

// To learn more about creating an EKS cluster with Pulumi, visit:
// https://www.pulumi.com/docs/reference/pkg/awsx/eks/

// For more information on deploying Helm charts with Pulumi, you can find documentation at:
// https://www.pulumi.com/docs/reference/pkg/kubernetes/helm/v3/chart/
```

In the above program:

1. We define an EKS cluster using the `@pulumi/eks` package.
2. The kubeconfig of the cluster is exported so it can be used to configure the Kubernetes provider.
3. A Kubernetes provider is instantiated with the kubeconfig from the EKS cluster.
4. We then define a Helm chart resource for deploying `api-graphql` using the version `1.0.0`. The properties of the Helm chart can be customized as per the requirements of your deployment.
5. Once deployed, you can export additional properties, such as the endpoint of the GraphQL API.

You need to install the NPM packages used in this program:

```bash
npm install @pulumi/pulumi @pulumi/awsx @pulumi/eks @pulumi/kubernetes
```

To run this Pulumi program, perform the following steps:

1. Ensure AWS CLI is configured with IAM credentials that have permissions to create and manage EKS clusters and associated resources.
2. Initialize a new Pulumi project using the Pulumi CLI.
3. Run `npm install` to install the required packages.
4. Copy the TypeScript code into `index.ts`.
5. Run `pulumi up` to create the resources. Follow the CLI prompts to perform the deployment.
6. After the deployment is successful, Pulumi will output the configured Kubernetes endpoint.

Please replace the `chart`, `version`, and `values` in the `apiGraphqlChart` resource as needed to match the specific `api-graphql` Helm chart you are referring to. Since I don't have specifics of the chart, you'll need to adjust these properties accordingly.

Remember that running this program will incur AWS costs, as it provisions real resources within your AWS account.