Deploy the jx helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a Helm chart on AWS EKS using Pulumi, you'll first need to provision an EKS Cluster. After provisioning the cluster, you can use the `helm.sh/v3.Chart` resource to deploy the Helm chart.

In this program, we'll create an EKS Cluster using the `eks.Cluster` resource from the Pulumi EKS library, which is a higher-level component designed to create and manage EKS clusters easily. Then, we'll deploy the Jenkins X (jx) Helm chart using the `kubernetes.helm.sh/v3.Chart` resource. The Helm chart requires Kubernetes, and the `kubernetes.helm.sh/v3.Chart` resource is specifically designed to deploy Helm charts on a Kubernetes cluster.

For deploying the `jx` Helm chart, you'll need to ensure that the chart is available in a Helm repository. For example, if the chart is available at `https://charts.jenkins.io`, you would specify the repository URL and the chart name in the resource arguments.

Here is a Pulumi program in TypeScript to deploy the `jx` Helm chart on an AWS EKS cluster:

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

// Create an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2", // gp2 is recommended by Jenkins X but could be any supported storage class
    deployDashboard: false, // Dashboard is not necessary for this setup
});

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

// Create a Kubernetes provider instance that uses our cluster from above.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy the Jenkins X Helm chart to the EKS cluster.
const jxChart = new k8s.helm.v3.Chart("jx", {
    chart: "jenkins-x", 
    version: "version-number", // specify the version you desire (use exact version for production)
    fetchOpts: {
        repo: "https://charts.jenkins.io", // example repository, replace with the actual URL if different
    },
}, { provider: provider });

// For demonstration purposes, the Helm release name is "jx" and the chart is "jenkins-x".
// Replace the `version-number` with the version of the Jenkins X chart you intend to use.

/*
Note: You might need to customize `values` to provide necessary configuration for Jenkins X chart
depending upon your requirements like domain settings, persistence, etc. You can do it like this:

const jxChart = new k8s.helm.v3.Chart("jx", {
    chart: "jenkins-x",
    values: {
        someValue: "configure-me",
        anotherValue: "configure-me-too",
        // ...
    },
    // ... other settings
}, { provider: provider });

*/

// Export the URL of the deployed Jenkins X, if applicable.
export const jenkinsUrl = pulumi
    .all([cluster.endpoint, cluster.kubeconfig])
    .apply(([endpoint, _]) => `http://${endpoint}`);
```

Explanation:
- We import Pulumi packages for EKS and Kubernetes, which will facilitate the creation of our resources.
- We define an EKS cluster using the `eks.Cluster` and specify desired capacities.
- We create a Kubernetes provider that knows how to communicate with our EKS cluster by using the kubeconfig that the EKS cluster outputs.
- We then declare a Helm chart resource, specifying its name and fetching options such as the Helm repository URL and potentially the chart's version.
- We pass our Kubernetes provider to the Helm chart resource to indicate that this chart should be deployed on the previously created EKS cluster.
- We export the URL of the Jenkins X instance. Depending on how Jenkins X is configured within the Helm chart, this URL might need to be constructed differently.
- Please replace the placeholder `version-number` with the actual desired version of your jx Helm chart.

Remember to replace the `version-number` and the Helm chart configuration under `values` if required by your setup. You will also need to configure AWS credentials and the Pulumi CLI to run this Pulumi program. After the above script is prepared, you can run it using the Pulumi CLI to provision your EKS cluster and deploy the jx Helm chart.