Deploy the docker-registry-proxy helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the docker-registry-proxy helm chart on AWS Elastic Kubernetes Service (EKS), we need to create an EKS cluster and then use Pulumi's Helm support to deploy the chart to that cluster. We'll create the following resources:

1. An EKS cluster, which is a managed Kubernetes service on AWS.
2. An instance of `eks.Cluster` from Pulumi's EKS package, which simplifies creating an EKS cluster.
3. The `helm.v3.Chart` resource to deploy the docker-registry-proxy Helm chart onto our EKS cluster.

Here's a step-by-step guide on how to do this using Pulumi with TypeScript:

### Step 1: Create an EKS Cluster

First, we'll create an EKS cluster with the required configuration such as the VPC and subnet IDs. You'll need to specify this configuration based on your AWS environment setup.

### Step 2: Define the Kubernetes Helm Chart

After the cluster is up and running, we'll define the Helm chart for `docker-registry-proxy`. You'll need to provide information on the Helm chart repository and version you are looking to deploy.

### Pulumi Program

Let’s go through the Pulumi program that deploys the `docker-registry-proxy` chart to an AWS EKS cluster:

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

// Step 1: Create an EKS cluster.
const vpc = new awsx.ec2.Vpc("vpc", { 
    numberOfAvailabilityZones: 2, // Availability Zones for fault tolerance
});
const cluster = new eks.Cluster("eks-cluster", {
    vpcId: vpc.id,
    subnetIds: vpc.publicSubnetIds,
    instanceType: "t2.medium", // Instance type for the EKS worker nodes
    desiredCapacity: 2,         // Number of worker nodes
    minSize: 1,
    maxSize: 3,
    enabledClusterLogTypes: ["api", "audit", "authenticator", "controllerManager", "scheduler"],
    // Additional settings can be specified as needed.
});

// Step 2: Deploy the docker-registry-proxy Helm chart.
const dockerRegistryProxyChart = new k8s.helm.v3.Chart("docker-registry-proxy", {
    chart: "docker-registry-proxy",
    version: "0.1.0", // Specify the chart version
    namespace: "default",
    fetchOpts: {
        repo: "https://your-helm-chart-repository/", // Specify the Helm chart repository URL
    },
    // Set values for the Helm chart as needed.
    values: {
        // Your docker-registry-proxy Helm chart values go here
    },
}, { provider: cluster.provider });

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

```

Here's what each part of the program does:

- **VPC Creation**: Set up a new VPC for our EKS cluster with `awsx.ec2.Vpc`. It's set to create the VPC across two availability zones for better fault tolerance.

- **EKS Cluster Creation**: The `eks.Cluster` creates an EKS cluster, including worker nodes of instance type `t2.medium`. It specifies the desired capacity of nodes as well as the VPC configuration using the previously created VPC. This includes enabling certain log types for the EKS cluster.

- **Helm Chart Deployment**: The `k8s.helm.v3.Chart` resource deploys the docker-registry-proxy Helm chart into the EKS cluster we created. It specifies the Helm chart to use and sets the chart values. The Helm chart repository URL and the version number need to be specified according to the Helm chart details.

- **Kubeconfig Export**: At the end, the program exports the kubeconfig of the EKS cluster, so you can directly use `kubectl` to interact with your Kubernetes cluster.

All the resources are created in the default Pulumi stack, which manages the deployment state. After running this program using Pulumi, the AWS EKS cluster will be set up and the `docker-registry-proxy` Helm chart will be deployed onto the EKS cluster. You can then use the exported kubeconfig to access your Kubernetes cluster as needed.

Make sure to replace placeholder values such as `https://your-helm-chart-repository/` with actual information specific to your use case.

To run this Pulumi program, you need to have Pulumi installed and AWS credentials configured on your system. The program is written in TypeScript, so ensure that you have Node.js installed. Save the code to a file like `index.ts`, run `npm install` to fetch the dependencies, and then execute the Pulumi CLI commands like `pulumi up` to deploy your infrastructure.