Topic lessonTopic: Kubernetes and EKS: structure, networking and upgrades
Amazon EKS explained: Kubernetes nodes, Pods and management responsibilities
EKS is an AWS service for using Kubernetes. A Pod is an application deployment unit, a node provides compute for Pods, and the control plane coordinates placement and state. Choosing EKS still leaves application configuration, data and required permissions to decide. Read one report API through separate views of structure and responsibility.
Distinguish the control plane, nodes, Pods and Deployments; explain differences from ECS terminology and the management and cost questions for each compute approach.
An image defines what to run; a container is an execution using it. No AWS or Kubernetes account is needed. Diagrams and counts are fixed synthetic examples, not observations of a running cluster.
Separate coordination from application execution
Kubernetes manages the placement, replication and updates of containerized applications. A cluster combines the control plane that coordinates them with nodes that run Pods. In EKS, distinguish AWS-managed components from the parts the customer designs and verifies.
| Term | Job | Do not confuse it with |
|---|---|---|
| Control plane | Accepts API requests and coordinates control toward the desired state and placement. | Not an HTTP proxy that every application request must traverse. |
| Node | Compute where Pods run; an EC2 instance is a node in an ordinary EC2-backed configuration. | Not necessarily one application per node. |
| Pod | One or more containers placed together as a unit. | Not an image or the desired replica count itself. |
| Deployment | Declares a Pod template and replicas, maintained and updated through controllers. | Not proof that every Pod has become Ready. |
Controllers reconcile observed state with desired state; the scheduler selects a suitable node for an unscheduled Pod. A Deployment declares the Pod template and replica target. These control functions differ from the application serving a user request.
A declared state differs from an observed state. Three desired replicas do not establish successful placement or readiness: resources, image access, permissions and application startup still matter. Ready is one availability signal, not proof that every business operation succeeds.
Fixed example: replicate one API across three Pods
This is a teaching configuration using EC2-backed nodes. A Deployment requests three report-api Pods. Each Pod template specifies an API container and one helper: two containers per Pod. The example explains roles and counts; it does not recommend a node count, co-location pattern or helper container.
- Deployment: 3 replicas → EKS control planeDeclare desired state
- EKS control plane → Three PodsControllers and scheduler reconcile
- Three Pods → Node (EC2-backed)Observe actual placement separately
- EKS control plane
- API, control and scheduling
- Deployment: 3 replicas
- report-api Pod template
- Three Pods
- Each: API + helper container
- Node (EC2-backed)
- Placement concept; actual placement uncollected
| Value | Fixed example | What it establishes |
|---|---|---|
| Desired Deployment replicas | 3 | A Pod target, not a node count. |
| Container definitions per Pod | One API + one helper | If all three Pods start, this example has six application containers. |
| Observed Pods | Two Ready; one Pending | Not all three Pods are Ready at this observation. |
| Node count and placement | Not collected in this table | Pod count alone does not determine node count or AZ distribution. |
Do not infer CPU shortage or an application failure from Pending alone. Inspect events, placement constraints, resource requests, image retrieval and the actual reason. The diagram does not supply unobserved placement success or availability.
Management scope also depends on the compute approach
| Approach | Examples managed by AWS | Examples the customer checks |
|---|---|---|
| EKS standard + managed node groups | Control plane, with node-group provisioning and update capabilities. | Plan and initiate applicable updates; manage workloads, data, access, placement and compatibility. |
| EKS Auto Mode | Control plane plus broader automation of compute and related infrastructure. | Supported features and configuration; workloads, data, access and costs. |
| EKS + Fargate | Underlying infrastructure for eligible Pods, without directly managing EC2 nodes. | Pod eligibility and networking, storage and feature constraints. |
| EKS + self-managed nodes | Control plane. | Broader node maintenance, updates and capacity responsibilities. |
More managed infrastructure does not remove application design. Decide what data to store, who may do what, which connections the application needs and how to validate updates. If compute approaches are mixed, identify the infrastructure used by each workload.
Check ECS terminology and separate cost layers
| ECS term | Kubernetes concept here | Caution |
|---|---|---|
| Task definition / task | Pod template / Pod | A useful comparison of definition and execution, not identical schemas or lifecycle. |
| ECS service | A workload controller such as Deployment | Compare maintaining replicas. A Kubernetes Service serves a different role. |
| Connectivity with an ALB and other resources | Service, Ingress/controllers and related resources | Inspect references and network conditions; matching names is not a migration plan. |
Review costs separately for cluster management, compute running Pods, and storage, networking and related capabilities. Three Pods alone do not determine a bill. Match the chosen approach, resources, duration, Region, support conditions and surrounding resources to current pricing and the actual configuration. This lesson promises neither a price nor free operation.
Read roles, desired state, observations and ownership
- Separate control plane, node, Pod and Deployment roles.
- Read the Pod template and replica target; do not substitute container or node counts.
- Inspect observed state, readiness, placement and events; retain unknowns.
- Identify update, access, network, data and cost responsibilities for the chosen infrastructure.
After reading roles and counts, examine how a Service selects destinations, what an Ingress/controller configures and which traffic a NetworkPolicy restricts. Control-plane health and a successful user operation remain separate observations.
Distinguish nodes, Pods and responsibilities
Choose an option to see the result and explanation.
Check, then explain in your own words
- Explain the three-Pod, two-containers-per-Pod example.
- Read three desired, two Ready and one Pending without inventing a cause.
- Identify the compute approach and decisions retained by the customer.
Check your understanding: After requesting three replicas in EKS, what should you verify separately?
The Pod template and container count, observed Pod state and readiness, node placement, and the chosen approach’s management and cost conditions.
A desired replica count establishes neither execution success nor node count. Healthy managed infrastructure alone does not prove all workloads or user operations succeed.
Sources and conditions checked
The official references used in this lesson are collected here with their scope, conditions and corresponding sections. Independent expert review and live AWS comparison have not been performed.
- Amazon EKS architectureChecked:
Scope and conditionsControl plane and compute roles differ; compute approach changes management scope, not application ownership. Documentation review; not live-cluster verification.
Used in this lessonSeparate coordination from application execution Management scope also depends on the compute approach Distinguish nodes, Pods and responsibilities
- Kubernetes: PodsChecked:
Scope and conditionsPods contain one or more co-scheduled containers; replicas are distinct Pods, not containers per Pod. Documentation review; not live-cluster verification.
Used in this lessonSeparate coordination from application execution Fixed example: replicate one API across three Pods Distinguish nodes, Pods and responsibilities
- Kubernetes: DeploymentsChecked:
Scope and conditionsPod-template updates and desired state; do not import ECS percentage formulas into Kubernetes. Documentation review; not live-cluster verification.
Used in this lessonSeparate coordination from application execution Distinguish nodes, Pods and responsibilities
- Amazon EKS: What is Amazon EKS?Checked:
Scope and conditionsEKS standard and Auto Mode management; access remains subject to Kubernetes and AWS IAM configuration. Documentation review; not live-cluster verification.
Used in this lessonManagement scope also depends on the compute approach Distinguish nodes, Pods and responsibilities
- Amazon EKS: Managed node groupsChecked:
Scope and conditionsManaged node-group capabilities differ from automatic completion of all maintenance; review workload compatibility. Documentation review; not live-cluster verification.
Used in this lessonManagement scope also depends on the compute approach
- Amazon EKS pricingChecked:
Scope and conditionsSeparate cluster support, compute and additional feature charges; no price or free-use guarantee from Pod count.
Used in this lessonCheck ECS terminology and separate cost layers
Scope and conditionsReview standard/extended support timing and upgrade policy separately from exact version eligibility; not a live-cluster check.
Used in this lessonCheck ECS terminology and separate cost layers