Deploy the gitlab-controller helm chart on AWS EKS

Installing Gitlab on AWS EKS with Helm

To deploy the GitLab controller Helm chart on AWS Elastic Kubernetes Service (EKS), we will need to go through several steps using Pulumi:

Create an Amazon EKS cluster.
Configure the Kubernetes provider to connect to the cluster.
Deploy the GitLab controller Helm chart to the EKS cluster.

For the Amazon EKS cluster creation part, we'll use the aws.eks.Cluster resource. This resource provisions an EKS cluster in AWS, including defining the necessary roles, VPC configuration, and cluster settings.

Once the EKS cluster is established, we need a way for Pulumi to interact with it. The kubernetes provider allows Pulumi to deploy Kubernetes resources to the cluster. It uses the generated kubeconfig from the EKS cluster to authenticate.

Finally, we'll deploy a Helm chart by using the helm.v3.Chart resource from the @pulumi/kubernetes package. Helm helps manage Kubernetes applications through Helm charts, which are packages of pre-configured Kubernetes resources.

Below is a TypeScript program that performs these steps. Before running this Pulumi program, make sure you have Pulumi installed, your AWS credentials configured, and Helm v3 installed.

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-gitlab-cluster", {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    storageClasses: "gp2",
    deployDashboard: false,
});

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

// Create a Kubernetes Provider instance that uses our EKS cluster's kubeconfig.
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the gitlab-controller Helm chart.
const chartName = "gitlab";
const gitlabChart = new k8s.helm.v3.Chart(chartName, {
    chart: "gitlab-controller",
    version: "<ChartVersion>", // Specify the version you want to deploy
    namespace: "gitlab",
    fetchOpts:{
        repo: "https://charts.gitlab.io/", // Location of the gitlab helm charts.
    },
}, { provider });

// Export the chart name of GitLab deployed.
export const gitlabChartName = chartName;

In this program, replace <ChartVersion> with the specific version of the GitLab controller Helm chart you want to deploy.

Here's what the program does, step by step:

We define eks.Cluster to provision an AWS EKS cluster with the desired number of nodes and the instance type. The desired capacity details how many worker nodes the cluster should have. Storage classes and dashboard deployment options are provided as well. Here, we've disabled the deployment of the Kubernetes dashboard since it's an optional component.
The kubeconfig of the cluster is exported so that it can be used by the Kubernetes provider and any external tool that needs to access the cluster.
A k8s.Provider instance is defined, passing in the kubeconfig from our cluster so that it has the necessary authentication to deploy resources to it.
The k8s.helm.v3.Chart resource specifies the GitLab chart deployment. It uses the chart and version parameters to determine which helm chart to deploy and which version. The namespace field specifies the Kubernetes namespace where GitLab will be deployed, and the fetchOpts.repo identifies the Helm repo containing the GitLab chart.

Remember to install @pulumi/eks and @pulumi/kubernetes packages using npm if they are not already installed:

npm install @pulumi/eks @pulumi/kubernetes

To deploy the GitLab controller Helm chart, you will navigate to the directory containing the above Pulumi program and run:

pulumi up

This command will provision the AWS resources, the EKS cluster, and deploy the GitLab Helm chart.

It's important to manage costs and security. Be aware that running an EKS cluster incurs charges in AWS, and always follow best security practices, such as defining least-privilege access policies for your resources.