Deploy the squidex helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Squidex Helm chart on an AWS Elastic Kubernetes Service (EKS) cluster, follow these steps:

1. **Set up an EKS cluster**: We'll create an Amazon EKS cluster, which is a managed Kubernetes service that makes it easy to run Kubernetes on AWS without needing to install and operate your own Kubernetes control plane.

2. **Create an ECR Repository**: Although not explicitly required for using a Helm chart, an Amazon Elastic Container Registry (ECR) repository can be useful if you're building and storing container images that you want to use with your EKS cluster.

3. **Deploy the Helm Chart**: Use Pulumi's Helm Chart resource to deploy Squidex to your EKS cluster. Ensure you have the `helm` command-line tool installed and configured to use the repository where the Squidex Helm chart is located.

Here's how you'd write the Pulumi TypeScript program to accomplish these tasks:

```typescript
import * as pulumi from '@pulumi/pulumi';
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-cluster', {
  // Specify the desired version for the Kubernetes cluster
  version: '1.21',
  // Configuration-specific values for deploying the EKS cluster
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 2,
  instanceType: 't2.medium',
  // Provision a node group for the EKS cluster
  nodeGroupOptions: {
    instanceType: 't2.medium',
  },
});

// Set up ECR if needed for custom container images.
const repo = new aws.ecr.Repository('my-repo', {
  imageScanningConfiguration: {
    scanOnPush: true,
  },
});

// Deploy Squidex chart using Helm.
const squidexChart = new k8s.helm.v3.Chart('squidex', {
  chart: 'squidex',
  version: '5.8.0', // replace with the appropriate chart version
  fetchOpts:{
    repo: 'https://squidex.github.io/squidex/helm', // replace with the actual repo URL
  },
  // Pass required configurations for your Squidex deployment.
  values: {
    // ...Customize Squidex values here...
  },
  // Make sure that Helm deployments occur in the created EKS cluster
  transformations: [
    (obj) => {
      if (obj.metadata) {
        obj.metadata.namespace = 'default';
      }
    },
  ],
}, { provider: cluster.provider });

// Export the cluster's kubeconfig and ECR repository URL.
export const kubeconfig = cluster.kubeconfig;
export const repositoryUrl = repo.repositoryUrl;
```

Explanation:
- We're creating an EKS cluster using the `eks.Cluster` class, specifying the Kubernetes version, and node group configuration to control the size and type of instances used.
- If required, an ECR repository is also being set up to host container images that may be used within the EKS cluster.
- The `k8s.helm.v3.Chart` resource from the Pulumi Kubernetes package is being used to deploy Squidex. It references a Helm chart for Squidex by providing the URL of the Helm repository and the version of the chart.
- We use `transformations` to make sure that all objects created by the Helm chart are placed in the `default` Kubernetes namespace.
- At the end of the program, we export the kubeconfig for the EKS cluster and the URL of the ECR repository if you need to push images there.

Remember to replace the chart version and Helm repository with the correct values for Squidex. Also, any custom values required by the Squidex Helm chart should be specified in the `values` object.

To deploy this infrastructure, you would save the code in a file (e.g., `index.ts`), and use the Pulumi CLI to create a new stack and update the resources as defined by the program.

Further, the provisioned resources such as the EKS cluster and ECR repository will incur costs on your AWS bill, so make sure to delete these resources using Pulumi if they're no longer needed.