EKS: A Simple Introduction

For the past month, I have been learning Kubernetes and always used it on Minikube in my local environment, but I always wanted to deploy different nodes on different servers and try to configure them and make them part of the cluster, mostly to understand how this setup would work compared to a Minikube setup, but also for checking performance metrics. However, I didn’t find a way to actually implement this, as I didn’t have any real servers or unused hardware with me.

But recently, for the past week, I have been learning AWS to become a solution architect, and in that process, a solution hit my mind: why not spin up 4-5 instances and move them under the same VPC and maybe give some elastic IPs and configure them under the same cluster? But just imagining the amount of configuration that I had to do gave me a headache. Of course, this is very much possible, but scaling the cluster will become a big issue. When I was looking for other solutions, I found out about Elastic Kubernetes Service provided by AWS

What is EKS?

EKS is a semi-managed Kubernetes service provided by AWS to manage the complexities of maintaining Kubernetes clusters. The specialty of this service is that AWS completely manages the control plane (i.e., the master nodes) and all of its tasks, while we only need to handle the worker nodes and their configuration.

Setting up the simplest k8s cluster requires:

1. Cluster name and version

2. IAM roles for provisioning nodes, secrets, and storage management

3. Configuring VPC and subnet

4. Defining the security groups for traffic flow

5. Specifying different nodes

6. Specifying instance types and the minimum/maximum number of nodes

7. Finally, the EKS cluster they should connect to.

Understand that these are the setups we have to do excluding the control plane setup, and this is again a lot of processes to go through. Configuring these things manually was very tedious but still doable, and this is when I learned about eksctl.

What is eksctl?

eksctl is a powerful open-source CLI tool that works on top of the AWS CLI. which makes the entire setup of settting up a kubernetes cluster into a single command. it also supports for custom network configuration and node group management too.

Installation of eksctl was pretty simple with just a few commands. Also, note that the AWS CLI should be installed and configured; if not, use the command below to configure it and proceed with the eksctl setup.

aws configure

Mac users can install ekctl with brew package manager

brew install eksctl

Unix users run:

# for ARM systems, set ARCH to: `arm64`, `armv6` or `armv7`
ARCH=amd64
PLATFORM=$(uname -s)_$ARCH

curl -sLO "https://github.com/eksctl-io/eksctl/releases/latest/download/eksctl_$PLATFORM.tar.gz"

# to Verify checksum
curl -sL "https://github.com/eksctl-io/eksctl/releases/latest/download/eksctl_checksums.txt" | grep $PLATFORM | sha256sum --check

tar -xzf eksctl_$PLATFORM.tar.gz -C /tmp && rm eksctl_$PLATFORM.tar.gz

sudo install -m 0755 /tmp/eksctl /usr/local/bin && rm /tmp/eksctl

Once the setup is done, we can see the options available with eksctl by running the command

eksctl --help

for my usecase where i wanted 3 nodes in a cluster of instance type t2.micro the setup is as simple as running the command

eksctl create cluster -n mycluster --nodegroup-name fnode -t t2.micro --nodes 2

And once the command is run, eksctl will do its job of allocating nodes, creating the cluster, creating the VPCs, and all of that. Once it’s done, it also sets our local kubectl to work with the cluster we set up! I mean, that’s as cool as something gets. Once I was able to use Kubectl, it was the normal kubectl commands to create pods, deployments, and other generic Kubernetes stuff.

Conclusion:

I was able to get hands-on experience creating a Kubernetes setup in a cloud-native environment and then a much more simplified setup for doing the same. By using EKS, I was able to bypass the complexities of managing the control plane (which was not necessary for my use case at least), and combining it with eksctl further streamlined the process, making it less error-prone. This process can still be automated by using Fargate to intelligently manage the count of deployable servers and scaling, but that is a much more advanced use case. Eksctl highlighted the importance of automation tools in simplifying infrastructure management, ultimately leading to more agile workflows. Overall, this hands-on experience has made me perspicacious for future challenges in Kubernetes management and cloud architecture.