DEV Community: Arnab Adhikary

Is anyone using AWS CodePipeline for the complete CI/CD pipeline?

Arnab Adhikary — Sat, 04 Jul 2026 19:25:39 +0000

Why AWS CodePipeline + ECS falls short for production-grade microservices (and how EKS fixes it)

Arnab Adhikary — Fri, 03 Jul 2026 20:02:11 +0000

I've been deep in the weeds with both stacks recently, and here's the pattern that keeps showing up: CodePipeline + ECS works great for a demo or a single-service app — but the moment you're running a real microservices architecture with 10+ services, it starts to strain.

Here's where it breaks down:

𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 𝗳𝗹𝗲𝘅𝗶𝘀𝗶𝗹𝗶𝘁𝘆
CodePipeline gives you rolling updates and basic blue/green via CodeDeploy, but true canary rollouts, traffic-weighted shifts, and automated rollback-on-metric-breach need a lot of custom glue. EKS + Argo Rollouts or Flagger gives you canary, blue/green, and progressive delivery natively, with automatic rollback based on Prometheus metrics.

𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 𝗴𝗿𝗮𝗻𝘂𝗹𝗮𝗿𝗶𝘁𝘆
ECS task definitions are coarse compared to Kubernetes primitives. Sidecars, init containers, fine-grained resource requests/limits, pod disruption budgets, topology spread constraints — this level of control simply doesn't exist in ECS the way it does in EKS.

𝗦𝗲𝗿𝘃𝗶𝗰𝗲 𝗺𝗲𝘀𝗵 & 𝘁𝗿𝗮𝗳𝗳𝗶𝗰 𝗺𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁
Once you need mTLS between services, retries, circuit breaking, or fine-grained traffic splitting across dozens of microservices, ECS leans hard on App Mesh — which is limited and increasingly an afterthought inside AWS. EKS integrates cleanly with Istio, Linkerd, or Cilium, which are the de facto standard and far more actively developed.

𝗚𝗶𝘁𝗢𝗽𝘀 𝗺𝗮𝘁𝘂𝗿𝗶𝘁𝘆
CodePipeline is push-based and AWS-native only. EKS unlocks GitOps via ArgoCD or Flux — declarative, auditable, drift-detecting deployments where the cluster state is always a mirror of Git. For multi-service, multi-team orgs, this is a massive operational win.

𝗣𝗼𝗿𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆 & 𝘃𝗲𝗻𝗱𝗼𝗿 𝗹𝗼𝗰𝗸-𝗶𝗻
An ECS task definition is AWS-only. A Kubernetes manifest runs on EKS, GKE, AKS, or on-prem with zero rewrite. For teams thinking about multi-cloud or hybrid strategies, that portability is not a nice-to-have — it's a hedge.

𝗘𝗰𝗼𝘀𝘆𝘀𝘁𝗲𝗺 & 𝗼𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆
The CNCF ecosystem around Kubernetes — Prometheus, Grafana, OpenTelemetry, Karpenter for node autoscaling, KEDA for event-driven scaling — is simply richer and more battle-tested at scale than what's available for ECS.

None of this means ECS is "bad" — for smaller teams or simpler architectures, it's genuinely a great choice with less operational overhead. But once you're running production-grade microservices at scale, with multiple teams shipping independently, EKS's flexibility, GitOps-native workflows, and CNCF ecosystem stop being "nice to have" and start being necessary.

Curious to hear from others running microservices in production — did you make the same ECS → EKS journey, or has ECS scaled fine for your use case?

Kubernetes Architecture: The Complete Beginner-to-Intermediate Guide

Arnab Adhikary — Mon, 22 Jun 2026 17:48:33 +0000

Most engineers learn Kubernetes by memorizing commands.

The best engineers understand how the architecture works behind the scenes.

Once you understand the architecture, troubleshooting becomes significantly easier.

Let's dive in.

Why Kubernetes Exists

Imagine manually managing:

Hundreds of servers
Thousands of containers
Constant deployments
Hardware failures
Traffic spikes

Without orchestration, managing this environment would be nearly impossible.

Kubernetes automates these tasks.

High-Level Architecture

A Kubernetes cluster consists of:

✅ Control Plane

✅ Worker Nodes

The Control Plane manages the cluster.

The Worker Nodes run applications.

Control Plane Components

API Server

The API Server acts as the gateway to the cluster.

Every action performed through:

kubectl get pods
kubectl apply -f deployment.yaml
kubectl delete pod nginx

ultimately communicates with the API Server.

ETCD

ETCD is the distributed key-value database of Kubernetes.

It stores:

Pods
Deployments
Services
ConfigMaps
Secrets
Cluster configuration

Think of ETCD as the single source of truth.

Without ETCD, Kubernetes loses its memory.

Scheduler

The Scheduler decides:

"Which worker node should run this pod?"

It evaluates:

Available CPU
Available Memory
Affinity rules
Taints and Tolerations
Resource constraints

Controller Manager

Controllers continuously monitor cluster health.

Examples:

ReplicaSet Controller
Node Controller
Deployment Controller

If something drifts from the desired state, controllers correct it.

Cloud Controller Manager

Used in cloud environments such as AWS.

Responsible for:

Load Balancers
Node lifecycle management
Cloud networking integration

Worker Node Components

Kubelet

The primary node agent.

Responsibilities:

Receives instructions
Creates pods
Monitors pod health

Container Runtime

Runs containers.

Examples:

containerd
CRI-O

Docker support now works through container runtimes rather than directly.

Kube Proxy

Responsible for service networking.

Provides:

Service discovery
Traffic routing
Load balancing

Pods

The smallest deployable unit in Kubernetes.

Applications ultimately run inside Pods.

What Happens During Deployment?

When a Deployment YAML is applied:

API Server receives request
ETCD stores desired state
Scheduler chooses node
Kubelet creates pod
Container runtime starts containers
Kube Proxy enables networking
Application becomes available

The Core Kubernetes Philosophy

Desired State Management.

You declare:

"I want 3 replicas."

Kubernetes continuously ensures:

"I have 3 replicas."

If one replica disappears, Kubernetes creates another automatically.

This self-healing behavior is one of Kubernetes' most powerful features.

Real-World Relevance

Understanding Kubernetes Architecture is critical for:

CKA Certification
DevOps Engineering
Site Reliability Engineering
Platform Engineering
Cloud Engineering
AWS EKS Administration

Without architectural knowledge, troubleshooting production incidents becomes extremely difficult.

Challenge Question

Suppose:

API Server is healthy
Worker Nodes are healthy
ETCD is unavailable

Can new Pods be scheduled?

Why or why not?

Drop your answer below 👇

kubernetes #cka #cloudnative #devops #sre #aws #eks #containers #docker #platformengineering #terraform #argocd #gitops #helm #prometheus #grafana #observability #linux #cloudcomputing #devsecops #opensource #siteReliabilityEngineering #cloudengineering #automation #infrastructureascode #learninginpublic

CKA Overview & Exam Pattern: The Kubernetes Certification That Actually Tests Your Skills

Arnab Adhikary — Sun, 14 Jun 2026 21:11:43 +0000

🚀 CKA Exam Overview: What Every Kubernetes Engineer Should Know Before Starting

If you're working in DevOps, Cloud Engineering, Platform Engineering, or SRE, chances are you've heard about the Certified Kubernetes Administrator (CKA) certification.

But here's what surprises most people:

⚠️ There are no multiple-choice questions.

You get a real Kubernetes environment and must perform actual administrative tasks within a limited time.

That makes the CKA one of the most practical certifications in the cloud-native ecosystem.

📋 CKA Exam Pattern

Category	Details
Exam Type	Performance-Based
Duration	2 Hours
Environment	Live Kubernetes Cluster
Passing Score	~66%
Proctoring	Online Remote Proctored
Difficulty	Intermediate to Advanced

🎯 Core Domains

1️⃣ Cluster Architecture, Installation & Configuration

Cluster setup
Control Plane components
Certificate management
Cluster upgrades

2️⃣ Workloads & Scheduling

Deployments
StatefulSets
DaemonSets
Jobs & CronJobs

3️⃣ Services & Networking

Services
Ingress
DNS
Network Policies

4️⃣ Storage

Persistent Volumes
Persistent Volume Claims
Storage Classes

5️⃣ Troubleshooting

Node failures
Pod failures
Control Plane issues
Network troubleshooting

Why CKA Matters in 2026

Modern organizations running workloads on AWS, Azure, and GCP increasingly rely on Kubernetes.

A certified administrator demonstrates the ability to:

✅ Manage production clusters

✅ Troubleshoot incidents efficiently

✅ Maintain reliability and scalability

✅ Support cloud-native application deployments

These skills directly align with DevOps and SRE responsibilities.

My 90-Day CKA Challenge

I'm beginning a structured 90-day CKA preparation journey.
Over the next few months, I'll share:

Study notes
Lab exercises
Troubleshooting scenarios
Exam strategies
Kubernetes tips & tricks
Real-world DevOps and SRE learnings

Discussion Time 👇

If you've already taken the CKA:

👉 What was the hardest section for you?

If you're preparing:

👉 What's your biggest challenge right now?

Let's learn from each other.