Deploy the docker helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a Docker Helm chart on AWS Elastic Kubernetes Service (EKS), you'll go through several steps:

Set up an EKS cluster: You'll create an EKS cluster which is the managed Kubernetes service provided by AWS.
Create an ECR repository: Although not always necessary for Helm charts, typically you'll want a place to store your Docker images. AWS provides Elastic Container Registry (ECR) for this purpose.
Use Helm to deploy the application: Once you have your cluster ready, you'll use Helm, a package manager for Kubernetes, to deploy your Dockerized application onto the EKS cluster.

Let's explore the code to accomplish this. I'll provide explanation for each part to ensure everything is clear.

First, ensure you have the following prerequisites:

Pulumi CLI installed and configured with your AWS account.
AWS CLI installed and configured, if needed for pushing Docker images to ECR.
Helm CLI installed locally, for packaging your chart or using Helm commands directly.
EKS Pulumi provider installed; we'll be using the eks package.

Below is a Pulumi program written in TypeScript that sets up an EKS cluster and an ECR repository. To keep things focused, the actual Helm chart deployment commands are often handled in a CI/CD pipeline or manually via the Helm CLI.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as eks from "@pulumi/eks";

// Step 1: Create an EKS cluster
// This provisions all the necessary infrastructure including the master nodes.
const cluster = new eks.Cluster("my-cluster", {
    // Specify the desired Kubernetes version
    version: "1.21",
    // By setting this to true, we skip creating the default node group and manage it manually.
    skipDefaultNodeGroup: true,
});

// Step 2: Create an ECR Repository
const repo = new aws.ecr.Repository("my-repo", {
    // Optionally, you can enforce immutability of images to ensure that once pushed, images cannot be altered.
    imageTagMutability: "IMMUTABLE",
});

// Export the EKS cluster name and ECR repository URL
export const clusterName = cluster.eksCluster.name;
export const kubeconfig = cluster.kubeconfig;
export const repositoryUrl = repo.repositoryUrl;

// Now you have an EKS cluster and a private ECR repository.
// The next steps typically involve building your Docker image, pushing it to ECR,
// and then using Helm to deploy your application onto the EKS cluster.
// This process would be as follows (run these on your command line):

// 1. Authenticate Docker with your ECR repository
// $ aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin <ACCOUNT_ID>.dkr.ecr.us-west-2.amazonaws.com

// 2. Build your Docker image (make sure to have a Dockerfile in your working directory)
// $ docker build -t <ACCOUNT_ID>.dkr.ecr.us-west-2.amazonaws.com/my-repo:mytag .

// 3. Push your Docker image to the ECR repository
// $ docker push <ACCOUNT_ID>.dkr.ecr.us-west-2.amazonaws.com/my-repo:mytag

// 4. Deploy using Helm
// $ helm upgrade --install my-release my-chart/ --set image.repository=<ACCOUNT_ID>.dkr.ecr.us-west-2.amazonaws.com/my-repo,image.tag=mytag,kubernetes.service.type=LoadBalancer

// You can find more information about AWS EKS at
// https://www.pulumi.com/docs/reference/pkg/eks/cluster/
// Information about the ECR repository can be found at
// https://www.pulumi.com/docs/reference/pkg/aws/ecr/repository/

This Pulumi program sets up basic infrastructure on AWS. Here are a few things to note about what this program is doing:

It initializes an EKS cluster and an ECR repository.
It exports important information such as the cluster name and the ECR repository URL. You will use these in your CI/CD pipeline or when deploying manually with Helm.
After running the Pulumi program, you will need to build your Docker image and push it to the created ECR repository.
Once your Docker image is in ECR, you can then deploy your application using the Helm CLI, referring to the Docker image you pushed.

Remember to replace placeholder values like <ACCOUNT_ID>, mytag, and my-chart/ with actual values you intend to use.

To apply this Pulumi program:

Save the code in a file with a .ts extension.
Run pulumi up to preview and deploy the changes.
Rotate your Docker to ECR and then use Helm as shown in the commented-out CLI commands.

This is a foundational approach to deploying a Docker Helm chart on AWS EKS using Pulumi. It's often the case that for real-world applications, you'll have more complex Helm charts with various dependencies and configurations, but structurally the approach remains similar.