AWS Learning Journey

Do You Really Need Kubernetes? Amazon EKS, Explained Honestly

Pods, deployments, services, and ingress — plus how EKS handles nodes, Fargate, IAM for pods, autoscaling, and load balancers. And when ECS is the better choice.

8 min read · 1401 words
AWSKubernetesAmazon EKSContainersDevOps
Do You Really Need Kubernetes? Amazon EKS, Explained Honestly cover image

AWS from Zero to Production — Phase 4, Part 4 of 6 · See the full series roadmap


Kubernetes is the most popular container platform in the world. It’s also the source of more “we spent six months on the platform and shipped nothing” stories than any other technology.

Both things are true.

Kubernetes gives you a powerful, portable, extensible API for running containers — and an enormous ecosystem. It also gives you a lot of moving parts to understand, upgrade, and secure.

This article teaches you the Kubernetes fundamentals, shows how Amazon EKS runs them on AWS, and helps you answer the honest question: does your team actually need it?

What you’ll walk away with


Kubernetes fundamentals

Kubernetes is an open-source system for running containers across a cluster of machines. You describe the desired state in YAML; Kubernetes continuously works to make reality match.

The core objects

A minimal deployment and service

apiVersion: apps/v1
kind: Deployment
metadata:
  name: orders-api
spec:
  replicas: 3
  selector:
    matchLabels: { app: orders-api }
  template:
    metadata:
      labels: { app: orders-api }
    spec:
      containers:
        - name: orders-api
          image: 111122223333.dkr.ecr.us-east-1.amazonaws.com/orders-api:1.0.0
          ports:
            - containerPort: 8080
          resources:
            requests: { cpu: 250m, memory: 256Mi }
            limits: { memory: 512Mi }
          readinessProbe:
            httpGet: { path: /health, port: 8080 }
---
apiVersion: v1
kind: Service
metadata:
  name: orders-api
spec:
  selector: { app: orders-api }
  ports:
    - port: 80
      targetPort: 8080
kubectl apply -f orders-api.yaml
kubectl get pods
kubectl rollout status deployment/orders-api

Engineer’s note: Always set resource requests and readiness probes. Without requests, the scheduler can’t place pods sensibly. Without readiness probes, traffic hits pods before they’re ready.


Amazon Elastic Kubernetes Service (EKS)

Amazon EKS runs the Kubernetes control plane for you: the API server and etcd, spread across multiple AZs, patched and scaled by AWS.

What AWS manages

What you still manage

Cost note: EKS charges per cluster per hour, plus the compute your workloads use. Clusters on versions past standard support are charged more for extended support. Check current EKS pricing.


Where pods run: compute options

Managed node groups

EC2 instances in an Auto Scaling group, provisioned and lifecycle-managed by EKS. You choose instance types; EKS handles draining nodes during updates.

Fargate profiles

Pods that match a Fargate profile — by namespace and labels — run on Fargate, with no nodes to manage. Each pod gets its own isolated compute. Some features, like DaemonSets, aren’t supported.

EKS Auto Mode

EKS Auto Mode goes further: AWS manages the compute, scaling, load balancing, storage, and core networking add-ons for the cluster. It’s the closest Kubernetes gets to “just run my pods.”

Self-managed nodes

You run and manage the EC2 instances yourself. Maximum control, maximum work.


IAM for pods: IRSA and Pod Identity

Pods often call AWS APIs. Giving every pod on a node the node’s IAM role is far too broad. Instead, map a Kubernetes service account to an IAM role.

IAM Roles for Service Accounts (IRSA)

EKS Pod Identity

aws eks create-pod-identity-association \
  --cluster-name prod \
  --namespace orders \
  --service-account orders-api \
  --role-arn arn:aws:iam::111122223333:role/orders-api-pod

Recommendation: Use Pod Identity for new workloads, unless you need IRSA for a specific reason. Either way, one role per application, least privilege.


Autoscaling

Kubernetes scales at two levels:

Pods

The Horizontal Pod Autoscaler (HPA) adds and removes pod replicas based on CPU, memory, or custom metrics.

Nodes

When pods can’t be scheduled because there’s no room, you need more nodes:


The AWS Load Balancer Controller

The AWS Load Balancer Controller watches Kubernetes objects and creates AWS load balancers for them:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: orders-api
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: orders-api
                port:
                  number: 80

ECS vs. EKS: the honest comparison

Choose ECS when

Choose EKS when

My take: Kubernetes is a great platform for platform teams. If you don’t have one, ECS on Fargate will get you to production faster, with less to maintain. That’s why this series’ main lab uses ECS — but everything you learn about images, roles, networking, and load balancers transfers directly to EKS.


Common mistakes


Key takeaways


Quick self-check

Test yourself before moving on:

  1. Which Kubernetes object gives a set of pods a stable network name?
  2. What does EKS manage for you, and what’s still your job?
  3. What’s the newer alternative to IRSA for giving pods IAM permissions?
  4. What does the AWS Load Balancer Controller create for an Ingress?

Answers

  1. A Service.
  2. EKS manages the control plane; you still own version upgrades, add-ons, and workload security — and nodes, unless you use Fargate or Auto Mode.
  3. EKS Pod Identity.
  4. An Application Load Balancer.

What’s next

In Part 5, we go serverless: AWS Lambda, API Gateway, Step Functions, EventBridge, SNS, SQS, dead-letter queues, and the Serverless Application Model.

Has Kubernetes been worth it for your team? I’d love to hear both sides in the comments.


Share this article

LinkedIn post draft