Deploy the suitecrm helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the SuiteCRM Helm chart on AWS EKS, we'll perform a series of steps in a Pulumi program. We will set up an EKS cluster, install the Helm chart, and ensure that the resources are appropriately configured and linked.

Here's a breakdown of the steps we'll implement in the TypeScript program:

1. **Set up an EKS Cluster**: We'll start by creating an EKS cluster using Pulumi's `eks.Cluster` ([docs](https://www.pulumi.com/registry/packages/eks/api-docs/cluster/)). This simplifies creating an EKS cluster, as this high-level component abstracts away many details.

2. **Install SuiteCRM Helm Chart**: We’ll use Pulumi's `kubernetes.helm.v3.Chart` ([docs](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/)) resource to deploy the SuiteCRM Helm chart onto the EKS cluster. This resource allows us to deploy Helm charts in a Kubernetes cluster managed by Pulumi.

Let's go ahead and create a Pulumi program to achieve this:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster("my-cluster", {
    // Define the desired settings for the EKS cluster such as version, node size, etc.
    // You can customize these settings based on your requirements.
    version: "1.21",
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
});

// Step 2: Deploy SuiteCRM using the Helm Chart
const suitecrmChart = new k8s.helm.v3.Chart("suitecrm", {
    chart: "suitecrm",
    version: "x.x.x", // Replace with the desired chart version
    fetchOpts: {
        repo: "https://helm.loodse.com/", // Replace with the actual SuiteCRM Helm chart repo URL if different
    },
    // Define any custom values for the chart, such as configuration settings or environment variables.
    // If there are none, you can remove the `values` field.
    values: {
        // Example: use NodePort instead of LoadBalancer for the service
        service: {
            type: "NodePort"
        },
        // Set any other necessary values required by the chart here
    },
}, { provider: cluster.provider });

// Step 3: Export the EKS cluster's kubeconfig and SuiteCRM service endpoint
export const kubeconfig = cluster.kubeconfig;
export const suitecrmServiceEndpoint = suitecrmChart.getResourceProperty("v1/Service", "suitecrm-suitecrm", "status").apply(status => {
    // Extract the endpoint information based on the service type. If it's NodePort, construct the URL using the cluster's nodes.
    if (status.loadBalancer?.ingress) {
        // This would be applicable if using LoadBalancer as the service type.
        const ingress = status.loadBalancer.ingress[0];
        return `http://${ingress.hostname || ingress.ip}`;
    } else {
        // For NodePort, get the port and construct the URL with one of the public IPs from the cluster nodes.
        const nodePort = status.ports[0].nodePort;
        const clusterNode = cluster.core.instance.workers[0].publicIp;
        return `http://${clusterNode}:${nodePort}`;
    }
});
```

In this program:

- The `eks.Cluster` resource creates a managed Kubernetes cluster on AWS EKS with a specified version and node configuration.
- The `kubernetes.helm.v3.Chart` resource installs SuiteCRM using its Helm chart. We specified the chart's name, possibly the version, and any configurations needed for SuiteCRM.
- We export the `kubeconfig` needed to interact with the Kubernetes cluster using command-line tools like `kubectl`.
- The `suitecrmServiceEndpoint` is an exported URL constructed based on the service type of SuiteCRM, allowing you to access the application in your browser.

Remember to replace `"x.x.x"` with the actual chart version you want to use and adjust the `repo` to the correct Helm chart repository URL for SuiteCRM.

To deploy this program, use the following commands after installing Pulumi and configuring AWS credentials:

```sh
pulumi up
```

This command runs the Pulumi program, provisioning the resources as described in the TypeScript code. After the deployment, you'll get the `kubeconfig` and `suitecrmServiceEndpoint` outputs, which you can use to interact with your EKS cluster and access the SuiteCRM application, respectively.