Deploy the jenkins-x-platform helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Jenkins X platform Helm chart on an AWS EKS cluster, follow these steps:

1. **Set up EKS Cluster**: First, create an EKS cluster on AWS using Pulumi's EKS package. EKS is the managed Kubernetes service provided by AWS, which makes it easy to run Kubernetes on AWS without needing to install and operate your own Kubernetes control plane.
2. **Create an ECR Repository**: Jenkins X will need a place to store container images, and AWS Elastic Container Registry (ECR) is a good choice for this. Although Jenkins X can work with any Docker registry, ECR is tightly integrated with AWS and EKS.
3. **Install Jenkins X using Helm**: Helm is a package manager for Kubernetes, which simplifies the deployment and management of applications on Kubernetes clusters. You will use Pulumi's `Chart` resource from the `kubernetes` package to deploy Jenkins X on the EKS cluster.

Here is a Pulumi program written in TypeScript that performs these tasks:

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

// Create an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    // Specify the desired settings for the cluster.
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    storageClasses: "gp2",
    deployDashboard: false,
});

// Create an ECR repository to store Docker images.
const repo = new aws.ecr.Repository("my-repository", {
    // ECR Repository configurations.
});

// Deploy the Jenkins X Helm chart.
const jenkinsxChart = new k8s.helm.v3.Chart("jenkins-x-platform", {
    chart: "jenkins-x-platform",
    version: "2.0.0", // Use the version number that is most suitable for your use case.
    namespace: "jx", // Assuming 'jx' is the namespace Jenkins X should be installed in.
    fetchOpts: {
        repo: "https://charts.jenkins.io", // This is the Helm chart repository containing Jenkins X.
    },
}, { provider: cluster.provider });

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

### Explanation

- We create an EKS cluster with the `eks.Cluster` class, which encapsulates the necessary AWS resources for the cluster, such as the EC2 instances and networking infrastructure. You can adjust the desired, minimum, and maximum capacity based on your requirement.

- We define an Elastic Container Registry (ECR) for Docker image storage using `aws.ecr.Repository`. While this step is not required for the Helm chart installation, it's a good practice for container image management when working with Jenkins X on EKS.

- We use the `k8s.helm.v3.Chart` resource to install the Jenkins X platform chart from its Helm repository. Ensure to specify the `version` to the one you'd like to use, and note that here we assume a namespace named `jx` where Jenkins X will be installed (you should create this namespace separately if it doesn't exist).

- Make sure to replace `"2.0.0"` with the appropriate chart version for Jenkins X that you wish to install. This version should be compatible with your Kubernetes cluster version and your desired Jenkins X features.

- We export the kubeconfig and repository URL. The kubeconfig will allow you to interact with your cluster using `kubectl`, and the repository URL is useful for pushing and pulling images to and from your ECR.

Before running this Pulumi program, ensure that you have set up your AWS credentials to allow Pulumi to create resources on your behalf. Once you have your AWS credentials configured, you can deploy the stack with `pulumi up`. After the stack is created, you can use the outputted `kubeconfig` to configure `kubectl` and administer your EKS cluster and the Jenkins X installation.