DEV Community

Cover image for Amazon EKS Series - Part 1: Introduction to EKS
Tandap Noel Bansikah
Tandap Noel Bansikah

Posted on

Amazon EKS Series - Part 1: Introduction to EKS

#aws #eks #kubernetes #devops

Introduction

Welcome to the first part of the Amazon EKS at Scale series! In this series, we'll explore Amazon Elastic Kubernetes Service (EKS) from the ground up, covering everything from basic concepts to advanced cluster management.

In this article, we'll cover:

  • What is Amazon EKS?
  • Why use EKS?
  • Understanding Worker Node options
  • Creating and connecting to an EKS cluster

What is Amazon EKS?

Amazon Elastic Kubernetes Service (EKS) is a managed Kubernetes service provided by AWS. It simplifies running Kubernetes by handling the complex parts of cluster management for you.

What AWS Manages for You

With EKS, AWS takes care of:

  • Provisioning and maintaining master nodes — AWS automatically sets up and maintains the master nodes that run the Kubernetes control plane, eliminating the need for you to manage this critical infrastructure.

  • Installing control plane processes:

    • API Server — The front-end for the Kubernetes control plane. It handles all REST requests for modifications to pods, services, and other resources.
    • Scheduler — Watches for newly created pods with no assigned node and selects a node for them to run on based on resource requirements.
    • etcd — A consistent and highly-available key-value store used as Kubernetes' backing store for all cluster data.

  • Scaling and backups of the cluster — AWS automatically handles scaling the control plane and maintains backups of your cluster state, ensuring high availability.

  • Patching and updating control plane components — Security patches and version updates are managed by AWS, keeping your control plane secure and up-to-date.

This means you can focus on deploying your applications rather than managing Kubernetes infrastructure.

Why Use EKS?

There are several compelling reasons to choose EKS:

  1. Simplified Operations — Running and scaling Kubernetes on your own requires significant expertise. You need to manage etcd clusters, configure API servers, and handle upgrades carefully. EKS removes this complexity by providing a production-ready control plane out of the box.

  2. Enhanced Security — Kubernetes security involves network policies, RBAC, secrets management, and more. EKS integrates natively with AWS IAM for authentication, making it easier to implement least-privilege access. Your control plane runs in an AWS-managed VPC, isolated from other customers.

  3. AWS Integration — EKS works seamlessly with services like:

    • IAM for authentication and authorization
    • VPC for network isolation
    • CloudWatch for logging and monitoring
    • ELB for load balancing
    • ECR for container image storage

This tight integration simplifies building production-grade applications.

Worker Nodes: Your Options

While EKS manages the control plane, you are responsible for the worker nodes (where your applications actually run). There are three ways to set up worker nodes:

1. Self-Managed Nodes

With self-managed nodes, you have complete control but also full responsibility:

  • Manual EC2 provisioning — You select and launch EC2 instances yourself, choosing instance types, AMIs, and configurations.
  • Install Kubernetes components — All worker processes must be installed manually:
    • kubelet — The primary node agent that ensures containers are running in pods
    • kube-proxy — Maintains network rules for pod communication
    • Container runtime — Software that runs containers (e.g., containerd, Docker)
  • Ongoing maintenance — Security patches, OS updates, and Kubernetes version upgrades are your responsibility.
  • Node registration — You must configure nodes to register with the EKS control plane.

Best for: Teams needing full control over node configuration, custom AMIs, or specific compliance requirements.

2. Managed Node Groups

Managed node groups let AWS handle the heavy lifting while you retain some control:

  • Automated provisioning — AWS creates and configures EC2 instances for you using EKS-optimized AMIs that come pre-configured with the necessary Kubernetes components.
  • Simplified lifecycle management — Create, update, or terminate nodes with a single API call. AWS handles rolling updates gracefully.
  • Auto Scaling integration — Each node group is backed by an Auto Scaling group, allowing automatic scaling based on demand.
  • Managed updates — AWS can update nodes to new AMI versions while respecting pod disruption budgets.

Best for: Most production workloads where you want a balance of control and convenience.

3. AWS Fargate

Fargate provides a fully serverless approach to running containers:

  • No node management — You don't provision, configure, or scale EC2 instances. AWS handles all infrastructure.
  • On-demand compute — Fargate spins up compute resources only when pods are scheduled, and removes them when pods terminate.
  • Right-sized resources — Based on your pod's CPU and memory requirements, Fargate automatically provisions appropriately sized compute.
  • Pay-per-use pricing — You only pay for the vCPU and memory your pods actually consume, billed per second.

Best for: Variable or unpredictable workloads, cost optimization, and teams wanting zero infrastructure management.

Creating an EKS Cluster

Prerequisites

To create an EKS cluster, you need to configure several components:

  1. Cluster configuration:

    • Cluster name — A unique identifier for your cluster within the region
    • Kubernetes version — The version of Kubernetes to run (EKS supports multiple versions)

  2. IAM role for the cluster — An IAM role that grants EKS permissions to:

    • Provision nodes — Create and manage EC2 instances for worker nodes
    • Access storage — Interact with EBS volumes and other storage services
    • Manage secrets — Access AWS Secrets Manager or Systems Manager Parameter Store

  3. Networking:

    • VPC and Subnets — The network where your cluster will run. Subnets should span multiple Availability Zones for high availability.
    • Security groups — Firewall rules controlling traffic to and from your cluster components

Creating Worker Nodes

After creating the cluster, set up your node group:

  1. Create a Node Group (a group of nodes for your Kubernetes environment)
  2. Select instance type
  3. Define min/max number of nodes
  4. Specify which EKS cluster to connect to

Methods to Create an EKS Cluster

There are three primary ways to create an EKS cluster:

1. AWS Console

The web-based approach - more steps involved but provides a visual interface.

2. eksctl CLI

A command-line tool that simplifies cluster creation:

eksctl create cluster
Enter fullscreen mode Exit fullscreen mode

This single command provisions:

  • Security groups
  • VPC
  • Subnets
  • Node groups
  • And more...

3. Infrastructure as Code (IaC)

Using tools like:

  • Terraform
  • Pulumi
  • AWS CloudFormation

Best for: Reproducible, version-controlled infrastructure.

Hands-On Demo: Creating Your First EKS Cluster

Step 1: Install eksctl

Follow the official AWS documentation to install eksctl OR you can use these steps on this github profile to install both kubectl and eksctl, these steps works for Linux, MacOS and Windows Link to github repo

Step 2: Ensure AWS Authentication

Make sure you can awsctl installed so that you can correctly setup your credentials

Step 3: Explore eksctl Commands 

# Get help
eksctl --help

# Explore create options
eksctl create --help

# Explore cluster creation options
eksctl create cluster --help
Enter fullscreen mode Exit fullscreen mode

Step 4: Create the Cluster 

eksctl create cluster \
  -n cluster1 \
  --nodegroup-name ng1 \
  --region us-east-1 \
  --node-type t2.micro \
  --nodes 2
Enter fullscreen mode Exit fullscreen mode

Breakdown of Each Option

  • eksctl create cluster

    Creates a new Amazon EKS cluster and provisions the required AWS infrastructure.

  • -n cluster1

    Sets the name of the EKS cluster to cluster1.

  • --nodegroup-name ng1

    Defines the name of the managed node group as ng1.

  • --region us-east-1

    Specifies the AWS region where the EKS cluster will be created.

  • --node-type t2.micro

    Chooses the EC2 instance type for worker nodes in the node group.

  • --nodes 2

    Sets the desired number of worker nodes in the node group to 2.

What This Command Creates

  • An Amazon EKS control plane managed by AWS
  • A managed EC2 node group named ng1
  • Two EC2 worker nodes using the t2.micro instance type
  • Required networking resources (VPC, subnets, and security groups) if they don’t already exist

Wait for the provisioning to complete.

Create cluster

It takes quite some time because it needs to create like the whole infrastructure for your, the Subnets, Node groups and so ... when it is done you will have something like this

Cluster provisioning complete

Step 5: Verify Created Resources

After creation, check the following in AWS Console:

  • VPC
  • Subnets
  • EKS Services
  • Compute > Node Group
  • EC2 Instances

First you can search EKS and you will see that our cluster has ben created

AWS cluster eks

and if you look further you will see the version of kubernetes we have

Cluster with version

We also have our Node group created with our nodes(EC2) you can see

Node groups compute

And if you check the instances you will see that our instances are up and running ...

Running nodes

And you can also see the security group and so

Security group

Connecting to Your EKS Cluster

Verify kubectl Configuration

You can verify that your kubeconfig file has been updated.

The kubeconfig file tells kubectl which cluster to connect to and
how to authenticate when communicating with the Kubernetes API server.

kubectl config view
Enter fullscreen mode Exit fullscreen mode

Check Your Nodes

You can also get your worker nodes directly from the terminal, and you can clearly see that using the tool eksctl all the cluster creation and worker nodes connection is automatically done for you

kubectl get nodes
Enter fullscreen mode Exit fullscreen mode

Get work nodes

If you see your worker nodes listed, your connection is successful!

Cleaning Up

To avoid unnecessary charges, delete your cluster when done:

eksctl delete cluster -n cluster1
Enter fullscreen mode Exit fullscreen mode

Delete Cluster

Summary

In this first part of the series, we covered:

  • What EKS is - A managed Kubernetes service where AWS handles the control plane
  • Why use EKS - Simplified operations, enhanced security, and AWS integration
  • Worker node options - Self-managed, Managed Node Groups, and Fargate
  • Cluster creation methods - Console, eksctl, and IaC
  • Basic cluster operations - Creating, connecting, and deleting clusters

What's Next?

In Part 2, we'll dive deeper into:

  • EKS architecture and components
  • How to Setup an EKS cluster using terraform.

Stay tuned!

Resources

Did you find this article helpful? Follow along with the series and drop a comment with your questions!

Top comments (0)