Amazon EKS manages the Kubernetes control plane. Choose how Pods run, reach storage, receive AWS permissions, and scale; Auto Mode also manages cluster infrastructure.
Cluster compute options
Amazon EKS runs Kubernetes, a system that places and maintains container workloads. Its control planeThe control plane maintains cluster state and schedules Kubernetes workloads. stores cluster state and schedules work. A nodeA node is a machine that runs containerized applications for a Kubernetes cluster. is the machine running that work; its kubelet agent keeps containers running inside PodsA Pod is a Kubernetes unit that runs one or more containers together., the units Kubernetes schedules.
How it works
- Choose compute for the workload. A cluster can mix the options below.
| Compute | Who manages it | Selection cue |
|---|---|---|
| Managed node group | EKS provisions an EC2 Auto Scaling group; you deploy patched node images | EC2 capacity with managed node lifecycle |
| Self-managed nodes | You maintain the nodes | Direct node maintenance |
| Fargate | AWS provides compute for matching Pods | Avoid managing virtual machines |
| Auto Mode | EKS provisions, scales, and patches nodes and integrates load balancing and block storage | Managed cluster infrastructure |
| Hybrid Nodes | You manage machines outside AWS | On-premises compute |
- A DaemonSetA DaemonSet runs copies of a Pod across nodes., which runs a copy of a Pod on nodes, cannot run on Fargate. Neither can privileged containers, GPUs,
HostPort, orHostNetwork. - Choose how operators and nodes reach the Kubernetes API endpoint, the cluster management address.
| Public access | Private access | API path |
|---|---|---|
| Enabled | Disabled | Default for new clusters; public endpoint |
| Enabled | Enabled | Cluster VPC traffic uses the private endpoint; public access CIDRs restrict internet access |
| Disabled | Enabled | Clients must be in the VPC or a connected network; cluster security group controls access |
- For persistent storage, use a persistent volumeA persistent volume provides storage independently of an individual Pod., which holds storage independently of a Pod. The Container Storage InterfaceThe Container Storage Interface connects Kubernetes volume operations to a storage driver. (CSI) driver connects Kubernetes storage requests to AWS storage APIs. Give the EBS CSI driver IAM permissions through Pod Identity or IAM roles for service accountsA service account is a Kubernetes identity used by applications in Pods..
| Storage choice | Fargate support |
|---|---|
| EBS | Cannot mount EBS |
| EFS persistent volume | Static provisioningStatic provisioning makes an existing storage resource available as a persistent volume.; no manual driver installation required |
Exam cues
- If the question says an EKS workload needs a GPU or a privileged node agent, think EC2 nodes, because Fargate does not support those features.
- If the question says the Kubernetes API must have no public access, think private endpoint access with public access disabled, because management clients must then use the VPC or a connected network.
- If the question says a Fargate Pod needs persistent file storage, think statically provisioned EFS, because Fargate cannot mount EBS.
- If the question says EBS volume creation fails with
UnauthorizedOperation, think CSI driver IAM permissions and role association, because the driver calls AWS APIs.
Remember
- New clusters default to public API access enabled and private access disabled.
- Public access CIDRs, meaning allowed IP address ranges, do not control the private endpoint.
- Managed node groups still require deploymentA Deployment maintains application replicas and manages updates to their version. of patched node images.
Trap: Choosing managed node groups does not transfer deployment of patched AMIs to AWS. Auto Mode includes operating system patching.
From the AWS docs (23)
- Standard EKS manages the Kubernetes control plane, which schedules workloads and maintains cluster state.
- A node is a machine that runs containerized applications; its kubelet keeps containers running in their Pods.
- An EKS cluster can combine Auto Mode nodes, managed node groups, self-managed nodes, Fargate, and Hybrid Nodes.
- Managed node groups provision and manage EC2 nodes in EKS-managed Auto Scaling groups in your account.
- For an EKS optimized AMI, AWS builds patched images and the customer deploys those images to managed node groups.
- EKS Auto Mode handles node provisioning, scaling, operating system patching, load balancing, and block storage integration.
- Self-managed nodes require the customer to maintain the nodes; Hybrid Nodes run on customer-managed machines outside AWS.
- EKS Fargate does not support DaemonSets, privileged containers, GPUs, HostPort, or HostNetwork.
- New EKS clusters default to public API endpoint access enabled and private endpoint access disabled.
- With public and private API access enabled, API requests from the cluster VPC use the private endpoint; public access CIDRs restrict only the public endpoint.
- With public API access disabled and private access enabled, kubectl must run within the VPC or a connected network; the cluster security group controls private endpoint access.
- The EBS Container Storage Interface driver manages EBS volumes for Kubernetes persistent volumes, storage that persists independently of a Pod.
- The EBS CSI driver needs IAM permissions to call AWS APIs; missing permissions can cause UnauthorizedOperation during volume provisioning.
- Associate the EBS CSI driver IAM role through Pod Identity or IAM roles for service accounts when configuring the add-on or controller service account.
- EBS volumes cannot be mounted by Fargate Pods.
- Fargate Pods can mount statically provisioned EFS persistent volumes without manual EFS driver installation; dynamic provisioning is not supported on Fargate.
- EKS clusters on Kubernetes 1.28 or later envelope-encrypt all Kubernetes API data, including Secrets, before it reaches etcd, using KMS with an AWS owned key by default or a customer managed KMS key you choose.
- Amazon EKS Connector registers any conformant Kubernetes cluster, such as one on premises or in another cloud, so its status, configuration and workloads show in the EKS console.
- Pod Identity associates an IAM role with a service account in a namespace of an EKS cluster; Pods use that service account to obtain workload permissions.
- Pod Identity roles trust the pods.eks.amazonaws.com service principal, and the same role trust can serve associations in multiple clusters without an OIDC provider.
- Pod Identity needs the Pod Identity Agent on nodes; Auto Mode includes it without a separate installation.
- IAM roles for service accounts use a cluster IAM OIDC provider and a service account token exchanged with STS using AssumeRoleWithWebIdentity.
- Pod Identity is supported for Pods on Linux EC2 workers, not Fargate or Windows EC2 workers.
Deployments and readiness
A Kubernetes DeploymentA Deployment maintains application replicas and manages updates to their version. describes an application’s desired replicasA replica is a copy of an application Pod., meaning copies of its PodsA Pod is a Kubernetes unit that runs one or more containers together., and updates their version. Health probes are checks that tell Kubernetes whether a container can serve requests or needs recovery. A ServiceA Kubernetes Service routes traffic to application Pods. provides traffic routing to the application Pods.
How it works
- Define a Deployment and update its container image for a release. A rolling update replaces part of the running Pods at a time. The Deployment also creates replacement replicas after failures.
- Bound the rollout with
maxUnavailable, the allowed unavailable Pods, andmaxSurge, the allowed extra Pods above the desired count. - Let the kubelet, the nodeA node is a machine that runs containerized applications for a Kubernetes cluster. agent, run probes to control startup, recovery, and traffic eligibility.
| Probe | Question it answers | Effect |
|---|---|---|
| Startup | Has initialization finished? | Holds readiness and liveness checks until success; terminates after the allowed startup time is exceeded |
| Readiness | Can this Pod accept requests? | Removes an unready Pod from Service traffic until recovery |
| Liveness | Is the application stuck? | Repeated failure causes termination and restart |
- For an external TCP endpoint, use a
LoadBalancerService managed by the AWS Load Balancer ControllerA component that watches Kubernetes objects and changes resources to match their configuration., which creates a Network Load Balancer (NLB). For HTTP routing through an IngressAn Ingress is a Kubernetes resource that describes application traffic routing., a Kubernetes routing resource, the controller creates an Application Load Balancer (ALB). - Inspect release history with
kubectl rollout history deployment. Revert a bad application release withkubectl rollout undo deployment <name>.
Exam cues
- If the question says temporary overload must stop traffic without restarting the application, think readiness, because an unready Pod leaves Service traffic until it recovers.
- If the question says slow initialization causes repeated liveness failures, think a startup probeA startup probe lets an application finish initialization before liveness and readiness checks run., because liveness and readiness wait for startup success.
- If the question says an EKS application needs a TCP load balancer, think a controller-managed
LoadBalancerService, because the controller creates an NLB.
Remember
maxUnavailabledefaults to 25%; choose a value compatible with required serving capacity.maxSurgecontrols extra Pods, not a percentage of user traffic.- Readiness controls Service traffic; liveness controls recovery from a stuck application.
Trap: A shared database outage can fail every replica’s probe at once. Restarting those replicas does not repair the database; avoid that dependency in liveness probes.
A successful readiness check makes the Pod ready.
A failed readiness check keeps the Pod out of Service traffic.
Ready Pods can receive Service traffic.
From the AWS docs (10)
- Kubernetes Deployments update application versions and create replacement replicas when replicas fail.
- A Deployment normally updates a portion of Pods at a time when its update requires Pod recreation.
- maxUnavailable limits unavailable Pods during a rolling update; its default is 25 percent. maxSurge limits Pods above the desired replica count.
- kubectl rollout history deployment shows rollout history; kubectl rollout undo deployment <name> rolls back a Deployment.
- A failed readiness probe removes a Pod from Kubernetes Service traffic until the probe succeeds, without requiring Pod termination.
- A liveness probe detects an unresponsive application; repeated failure causes termination and restart.
- A startup probe delays readiness and liveness probes until startup succeeds; exceeding its allowed startup time causes termination.
- The AWS Load Balancer Controller creates an NLB for a Kubernetes LoadBalancer Service and an ALB for a Kubernetes Ingress.
- Making probes depend on a shared external database can cause all replicas to fail their health checks at once.
- An IAM role gets Kubernetes permissions only after the cluster maps it, through an EKS access entry or the older aws-auth ConfigMap; without the mapping, kubectl returns Unauthorized even though AssumeRole worked.
Services and load balancers
A Kubernetes ServiceA Kubernetes Service routes traffic to application Pods. gives application PodsA Pod is a Kubernetes unit that runs one or more containers together. a traffic destination while individual Pods change. The AWS Load Balancer ControllerA component that watches Kubernetes objects and changes resources to match their configuration. watches Service and IngressAn Ingress is a Kubernetes resource that describes application traffic routing. objects and creates AWS load balancers for them. An Ingress describes application routing, such as HTTP paths.
How it works
- Choose the network entry object. Layer 4The transport layer used for network traffic such as TCP and UDP. means transport traffic such as TCP and UDP; Layer 7The application layer used for traffic such as HTTP and HTTPS. means application traffic such as HTTP and HTTPS.
- Ensure the intended controller manages the object. An annotationConfiguration metadata attached to a Kubernetes resource and interpreted by a controller. is configuration attached to a Kubernetes resource; controller annotations choose target mode and placement.
- Select the target type, meaning what the load balancer registers as a destination. Instance targets receive traffic at NodePortA Service port on a worker node that forwards incoming traffic toward application Pods., a port exposed on a worker nodeA node is a machine that runs containerized applications for a Kubernetes cluster., before Kubernetes forwards it to a Pod. IP targetsA load balancer destination registered by IP address, such as a Pod address. receive traffic directly at Pod addresses.
- Provide eligible subnets and choose internal or internet-facing placement. A subnet is a network address range within an AZ. Auto-discovery uses role tags unless subnet IDs are specified explicitly.
- During rollout, coordinate new target registration with a Pod readiness gateAn additional condition that a Pod must satisfy before Kubernetes treats it as ready., an additional condition for accepting a Pod as ready. It can wait for load balancer health before old Pods are removed.
| Resource or target choice | Result | Selection cue |
|---|---|---|
Controller-managed LoadBalancer Service |
NLB | TCP or UDP traffic |
| Controller-managed Ingress | ALB | HTTP or HTTPS routing |
| Instance target | NodePort, then Pod forwarding | ALB default; Service must expose NodePort or LoadBalancer |
| IP target | Direct Pod traffic and health checks | Required for Fargate targets |
For ALB Pod targets, set alb.ingress.kubernetes.io/target-type: ip. For NLB Pod targets, set service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip. ClusterIPThe internal address used for a Kubernetes Service. is the Service’s internal address; direct IP targeting bypasses that forwarding hop. ALB settings · NLB settings
Exam cues
- If the question says expose transport traffic such as TCP, think a controller-managed
LoadBalancerService, because it provisions an NLB. - If the question says route HTTP to Fargate Pods, think ALB Ingress with IP targets, because Fargate has no instance target path.
- If the question says Pods are ready before external targets are healthy, think a readiness gate, because Kubernetes readiness and load balancer registration can complete at different times.
- If the question says a Service unexpectedly created a Classic Load Balancer, think controller ownership, because the legacy controller has a different default.
Remember
- ALB: at least two subnets in different AZs, each with eight free IP addresses.
- NLB: at least one subnet with eight free IP addresses.
- Auto-discovery tags: public
kubernetes.io/role/elb: 1; privatekubernetes.io/role/internal-elb: 1. - ALB scheme:
alb.ingress.kubernetes.io/schemecan selectinternet-facingorinternal.
Trap: A
LoadBalancerService does not identify the responsible controller by itself. Verify ownership before assuming the NLB behavior described here.
From the AWS docs (16)
- A Kubernetes Service exposes application replicas through one IP address or name.
- The AWS Load Balancer Controller watches Kubernetes Service and Ingress resources and creates corresponding AWS load balancers.
- With AWS Load Balancer Controller, a LoadBalancer Service creates an NLB and an Ingress creates an ALB.
- NLB handles Layer 4 network traffic such as TCP and UDP; ALB handles Layer 7 application traffic such as HTTP and HTTPS.
- The legacy AWS cloud-provider controller creates Classic Load Balancers by default; the AWS Load Balancer Controller creates NLBs, not Classic Load Balancers.
- With instance targets, the load balancer sends traffic to a node NodePort and Kubernetes forwards it to a destination Pod.
- With IP targets, the load balancer sends traffic and health checks directly to Pod IP addresses, bypassing the node NodePort and Service ClusterIP hops.
- ALB instance mode is the default; its Service must be NodePort or LoadBalancer.
- Set alb.ingress.kubernetes.io/target-type: ip on an Ingress for direct Pod targets; Fargate and Hybrid Nodes require IP targets.
- Set service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip on a Service to select NLB IP targets.
- An ALB needs at least two subnets in different AZs, each with at least eight free IP addresses.
- An NLB needs at least one subnet, with at least eight available IP addresses.
- Subnet auto-discovery uses kubernetes.io/role/elb: 1 for public and kubernetes.io/role/internal-elb: 1 for private subnets; explicit subnet IDs avoid this discovery requirement.
- The ALB scheme annotation alb.ingress.kubernetes.io/scheme selects internet-facing or internal placement.
- With IP targets, a Pod readiness gate can wait for the load balancer target to become healthy before a rollout removes old Pods.
- Annotations on Kubernetes resources configure AWS Load Balancer Controller behavior, including load balancer settings.
Pod identity
EKS workload identity gives an application AWS permissions through a Kubernetes service accountA service account is a Kubernetes identity used by applications in Pods., an identity used by PodsA Pod is a Kubernetes unit that runs one or more containers together.. Pod Identity associates that service account with an IAM role, which grants temporary AWS credentials. IAM roles for service accounts (IRSA) is another mechanism for the same purpose.
How it works
- Create an IAM role with the application’s permissions. For Pod Identity, its trust policy, which names who may assume the role, uses the serviceA Kubernetes Service routes traffic to application Pods. principal
pods.eks.amazonaws.com. - Associate the role with a service account and namespaceA namespace groups named Kubernetes resources within a cluster. in the EKS cluster. A namespace groups Kubernetes resources. Configure application Pods to use that service account.
- Run the Pod Identity Agent on nodes. Auto Mode includes the agent. The agent calls the EKS Auth API using
AssumeRoleForPodIdentityto retrieve temporary credentials. - Use a supported AWS SDK with its default credential chainA credential chain searches credential sources in order and uses the first valid credentials it finds., the ordered search for credentials, or its container credential provider. The SDK retrieves credentials from the agent.
- For IRSA, configure the cluster’s IAM OpenID ConnectOpenID Connect provides identity tokens that IAM can trust for Kubernetes workload authentication. (OIDC) provider, which lets IAM trust cluster-issued identity tokens. The SDK exchanges the service account token with AWS STS using
AssumeRoleWithWebIdentity. - For cross-account access, associate a role in the cluster account and specify a target role in the resource account. Grant the first role permission to assume the target and configure the target’s trust. EKS performs the role chainingUsing credentials from one assumed role to assume another role., or successive role assumptions, and supplies target credentials.
A session policyA policy that restricts the permissions available during a temporary role session. is an additional policy that limits a role session. An association session policy requires session tags to be disabled and cannot grant more than the role allows. If a target role is specified, the policy limits the target role only.
The nodeA node is a machine that runs containerized applications for a Kubernetes cluster. role needs eks-auth:AssumeRoleForPodIdentity, and private nodes need an EKS Auth interface endpoint. If IPv6 localhost addresses are unavailable, disable the agent’s IPv6 configuration so it can start.
| Mechanism | Credential path | Distinguishing requirement |
|---|---|---|
| Pod Identity | Node agent and EKS Auth | Linux EC2 workers; role trusts pods.eks.amazonaws.com |
| IRSA | Service account token and STS | Cluster IAM OIDC provider |
| Fargate Pod execution role | Infrastructure operations such as image pulls | Does not grant application container permissions |
Exam cues
- If the question says reuse a workload role across EKS clusters without per-cluster OIDC providers, think Pod Identity, because the shared service principal can serve associations in each cluster.
- If the question says a Fargate application needs AWS API permissions, think IRSA, because Pod Identity does not support Fargate and the execution role is for infrastructure.
- If the question says an association exists but old credentials are still used, think the SDK credential chain, because an earlier credential source takes precedence.
- If an EKS Pod needs S3 access in another account without application-managed role chaining, think a Pod Identity target role, because EKS assumes both roles and supplies the resulting credentials.
- If a proxy prevents agent credential requests, exclude the agent’s link-local IPv4 and IPv6 addresses with
no_proxyorNO_PROXY. - If private nodes cannot reach EKS Auth, think its interface endpoint and node-role permission, because the agent must call that API.
Remember
- Pod Identity supports Linux EC2 workers; Fargate and Windows EC2 workers are excluded.
- Auto Mode includes the Pod Identity Agent.
- Restrict the EC2 Instance Metadata ServiceInstance Metadata Service exposes EC2 instance information and instance-role credentials to software on the instance. (IMDS), the node’s metadata and role-credential endpoint, to prevent application access to the node role.
- Target-role support for cross-account Pod Identity associations was added in June 2025.
- Association changes do not clear cached credentials. The cache lasts six hours without a target role and 59 minutes with one; recreating Pods can apply changes sooner.
Trap: A workload role association alone does not isolate node-role credentials. IMDS access must also be restricted.
Trap: Pods using
hostNetwork: truealways have IMDS access, even when Pod Identity credentials are enabled.
The workload SDK requests credentials from the node agent.
The agent calls AssumeRoleForPodIdentity on EKS Auth.
The role association determines the temporary role credentials returned through the agent.
From the AWS docs (20)
- Pod Identity associates an IAM role with a service account in a namespace of an EKS cluster; Pods use that service account to obtain workload permissions.
- A Kubernetes service account is an identity used by applications running in Pods.
- Pod Identity roles trust the pods.eks.amazonaws.com service principal, and the same role trust can serve associations in multiple clusters without an OIDC provider.
- Pod Identity needs the Pod Identity Agent on nodes; Auto Mode includes it without a separate installation.
- The agent uses AssumeRoleForPodIdentity with the EKS Auth API to retrieve temporary credentials and makes them available to workload SDKs.
- Pod Identity workloads need a supported AWS SDK using the default credential chain or container credential provider; credentials found earlier in that chain take precedence.
- Pod Identity is supported for Pods on Linux EC2 workers, not Fargate or Windows EC2 workers.
- IAM roles for service accounts use a cluster IAM OIDC provider and a service account token exchanged with STS using AssumeRoleWithWebIdentity.
- The Fargate Pod execution role grants infrastructure permissions such as pulling images; it does not grant application containers AWS permissions.
- Restrict access to the EC2 Instance Metadata Service to prevent Pods retrieving the node role in addition to workload-role credentials.
- Pod Identity can assume a same-account association role and then a target role in another account, returning target-role credentials to the Pod.
- The association role needs permission to assume the target role, and the target role must trust the association role; session tags also require sts:TagSession.
- In June 2025, EKS Pod Identity added simplified cross-account access using a target role in the association.
- A Pod Identity association session policy restricts role permissions by intersection and requires disableSessionTags to be true; with a target role it restricts that role only.
- Association changes do not reset cached credentials; the cache lasts six hours without a target role and 59 minutes with one. Recreating Pods can apply changes sooner.
- Pods using a proxy must exclude the Pod Identity Agent link-local addresses 169.254.170.23 and fd00:ec2::23 from the proxy using no_proxy or NO_PROXY.
- Pods with hostNetwork true always have IMDS access, although supported SDKs and the CLI use Pod Identity credentials when enabled.
- The node role needs eks-auth:AssumeRoleForPodIdentity for the Pod Identity Agent to call EKS Auth; AmazonEKSWorkerNodePolicy includes this permission.
- Nodes in private subnets need an EKS Auth interface endpoint for the Pod Identity Agent to reach the EKS Auth API.
- The Pod Identity Agent listens on IPv4 and IPv6 by default and cannot start when IPv6 localhost addresses are unavailable unless its IPv6 configuration is disabled.
Pod and node scaling
EKS scaling has separate workload and compute decisions. The Horizontal PodA Pod is a Kubernetes unit that runs one or more containers together. Autoscaler (HPA) changes the number of Pod replicasA replica is a copy of an application Pod.. A nodeA node is a machine that runs containerized applications for a Kubernetes cluster. autoscaler supplies machines where those Pods can run. More requested replicas need somewhere to fit.
How it works
- Give Pods resource requestsA resource request reserves CPU or memory for Kubernetes placement decisions., the CPU and memory reservations used for placement. Configure HPA with a metric target.
- HPA adjusts the replica count to meet its metric target.
- When replicas cannot be scheduled, use a compute scaling mechanism.
| Mechanism | Scaling action | Capacity model |
|---|---|---|
| Cluster Autoscaler | Simulates placement and adjusts desired capacity | Existing EC2 Auto Scaling groups |
| Karpenter | Provisions compute for workload requirements | Instance selection from workload constraints |
| EKS Auto Mode | Provisions, consolidates, and removes nodes | Managed compute scaling built on Karpenter |
- Check that resource requests fit the possible nodes. A node group must have compatible labelsA label is a key-value attribute used to identify or select Kubernetes resources., key-value attributes, and taintsA taint restricts which Pods a node accepts., restrictions on which Pods it accepts. More nodes with incompatible scheduling properties will not solve placement.
Exam cues
- If the question says HPA increased replicas but they cannot be scheduled, think node capacity and placement constraints, because HPA changes replicas without provisioning nodes.
Remember
- The HPA walkthrough documents a five-minute default scale-down timeframe; it is configurable.
Trap: HPA changes Pod replicas, but it does not add nodes. Unschedulable Pods need compatible node capacity.
HPA requests more replicas from its metric target.
Unschedulable replicas expose the need for additional compute.
The node autoscaler supplies compatible node capacity.
From the AWS docs (7)
- The Horizontal Pod Autoscaler changes Pod replica counts to meet a configured metric target; it does not provision nodes.
- Resource requests are the CPU and memory reservations used when scheduling Pods; node groups must have capacity and scheduling properties that fit unscheduled Pods.
- Cluster Autoscaler watches unschedulable Pods and underused nodes, simulates placement changes, and changes EC2 Auto Scaling group desired capacity.
- Cluster Autoscaler expects nodes within a node group to have identical scheduling properties, including labels, taints, and resources.
- Karpenter provisions compute according to workload compute, storage, acceleration, and scheduling requirements.
- Auto Mode builds on Karpenter, creates nodes when Pods do not fit existing nodes, and consolidates workloads and removes nodes.
- The EKS HPA walkthrough documents a default five-minute scale-down timeframe that can be changed.
Pod troubleshooting
EKS PodA Pod is a Kubernetes unit that runs one or more containers together. troubleshooting separates placement failures, image retrieval failures, and container startup failures. A Pod is the unit Kubernetes places on a nodeA node is a machine that runs containerized applications for a Kubernetes cluster., the machine that runs it. Start with its state and events, then inspect the component responsible for the failure.
How it works
- Use
kubectl get podsin the affected namespaceA namespace groups named Kubernetes resources within a cluster., a named group of Kubernetes resources, to locate the Pod state. Usekubectl describe podfor events andkubectl logsfor startup errors. Specify the intended--contextand namespace. - Follow the evidence rather than repeatedly deleting Pods. Resource requestsA resource request reserves CPU or memory for Kubernetes placement decisions. reserve CPU and memory for placement. Node affinityA rule constraining which nodes can host a Pod. and
nodeSelectorconstrain eligible nodes; taintsA taint restricts which Pods a node accepts. restrict placement unless a Pod has a matching tolerationA Pod setting allowing placement despite a matching node taint., permission to tolerate that restriction. - For image failures, inspect the image referenceThe registry location and version identifier used to retrieve a container image. and connectivity to ECR, the container image registry. Pull permissions belong to the EC2 node role or Fargate Pod execution role.
- Enable the relevant control-plane log type when the problem concerns cluster management. The control planeThe control plane maintains cluster state and schedules Kubernetes workloads. accepts API requests, places Pods, and maintains desired cluster state. Export is off by default.
| Pod evidence | Check next |
|---|---|
Pending with insufficient CPU or memory |
Requests against available node capacity |
FailedScheduling with placement restrictions |
Node affinity, nodeSelector, taints, and tolerations |
ImagePullBackOff |
Image tag, ECR connectivity, and image-pull permissions |
Agent CrashLoopBackOff |
Startup logs for configuration errors or missing volume mounts |
| Control-plane log type | Diagnostic purpose |
|---|---|
api |
API server component activity |
audit |
Actions by users and system components |
authenticator |
IAM credential authentication |
controllerManager |
Core reconciliation loops, which maintain desired state |
scheduler |
When and where Pods are placed |
For node-level diagnostics, the EKS log collector gathers logs at /etc/eks/log-collector-script/eks-log-collector.sh when installed.
Exam cues
- If the question says Pod events show placement restrictions, think node selection and tolerations, because additional incompatible nodes will not satisfy those rules.
- If the question says an image cannot be pulled, think the image path, registry connectivity, and pulling role, because application code cannot start without its image.
- If the question says find who changed a cluster resource, think
audit, because it records the responsible users and components. - If the question says diagnose IAM authentication, think
authenticator, because that component handles IAM credential authentication.
Remember
- Enable each of the five control-plane log types separately.
- Destination:
/aws/eks/<cluster-name>/clusterin the same account. - CloudWatch Logs ingestion and storage charges apply; delivery is best effort.
Trap: Turning on API server logs does not turn on audit, authenticator, controllerA component that watches Kubernetes objects and changes resources to match their configuration. manager, or scheduler logs. Select the required types explicitly.
From the AWS docs (17)
- EKS schedules Pods on nodes, which are machines running containerized applications.
- Use kubectl get pods for status, kubectl describe pod for events, and kubectl logs for startup errors.
- Insufficient node CPU or memory can leave agent Pods Pending; inspect resource requests and node capacity.
- Node affinity or taints can cause FailedScheduling; inspect nodeSelector and tolerations.
- ImagePullBackOff can result from an incorrect image tag or unreachable ECR; check the image reference and network access.
- For agent Pods in CrashLoopBackOff, inspect logs for invalid configuration or missing mounts.
- ECR image pulls need permissions on the EC2 node IAM role or the Fargate Pod execution role.
- EKS control-plane logs are not sent to CloudWatch Logs by default; each type is enabled individually per cluster.
- The api control-plane log type records API server component activity.
- The audit log type records actions by users, administrators, and system components affecting the cluster.
- The authenticator log type records the EKS control-plane component authenticating IAM credentials.
- The controllerManager log type records the component managing Kubernetes core control loops.
- The scheduler log type records the component deciding when and where Pods run.
- Enabled control-plane logs go to CloudWatch Logs in the same account under /aws/eks/<cluster-name>/cluster.
- Enabled EKS control-plane logs incur CloudWatch Logs ingestion and storage charges, and delivery is best effort.
- The EKS node log collector at /etc/eks/log-collector-script/eks-log-collector.sh gathers node diagnostics when present.
- A Kubernetes namespace groups resources within a cluster.
Canary and blue/green deployments
Blue/green and canary deploymentsA Deployment maintains application replicas and manages updates to their version. keep an old EKS application version available while introducing another. Blue/green switches traffic after testing the replacement. A canary exposes a small traffic share first and expands it after examining metrics.
How it works
- Run the new version as a separate Deployment, a Kubernetes object that maintains application replicasA replica is a copy of an application Pod.. Keep the existing Deployment available.
- Choose the traffic transition.
| Pattern | What changes | Release control |
|---|---|---|
| Rolling | PodsA Pod is a Kubernetes unit that runs one or more containers together. within a Deployment are replaced gradually | maxUnavailable and maxSurge |
| Blue/green | A new Deployment replaces the old version as the traffic destination | Test new Pods, then change the Service selectorA Service selector chooses destination Pods by their labels. |
| Canary | A smaller new Deployment receives a small traffic share | Increase its traffic and replicas after acceptable metrics |
- For blue/green, change the Service selector, the labelsA label is a key-value attribute used to identify or select Kubernetes resources. used to choose destination Pods, after testing the new version. Restore the old destination if it fails.
- For a canary, use routing or rollout tooling to control exposure. AWS describes Flagger with Istio. Expand only after examining metrics; on failure, stop sending traffic to the canary.
- Remove the old environment only after accepting the replacement.
Exam cues
- If the question says test a replacement before switching all live traffic, think blue/green, because the old Deployment remains a rollback destination.
- If the question says expose a small traffic share and expand after observing metrics, think canary, because the new version runs alongside the old one during evaluation.
- If the question says limit extra Pods during a normal Deployment rollout, think
maxSurge, because it controls capacity during rolling replacement.
Remember
- Rolling
maxUnavailabledefaults to 25%. - Blue/green uses a Service selector change to select the replacement Pods.
- Kubernetes needs additional routing or rollout tooling for a controlled canary.
Trap: A rolling update’s Pod capacity limits do not define a canary traffic percentage.
Keep the old Deployment available as a traffic destination.
Switch after testing for blue/green, or send a small initial share for canary.
Use metrics to decide whether to expand the canary or restore old-version traffic.
From the AWS docs (6)
- Rolling updates replace Pods gradually; maxUnavailable limits unavailable Pods and defaults to 25 percent, while maxSurge limits extra Pods.
- For blue/green in Kubernetes, create a new Deployment alongside the existing version, test its Pods, and change the Service selector to direct traffic to it.
- Blue/green rollback restores traffic to the old version; terminate the old environment only after accepting the new version.
- A canary deployment runs a smaller new Deployment beside the old one, sends a small traffic share to it, and increases traffic and replicas when metrics are acceptable.
- If a canary fails, route traffic back to the old Deployment and stop sending traffic to the new version.
- Kubernetes has no native canary deployment mechanism; AWS describes using tools such as Flagger with Istio.
EKS operational controls
Amazon EKS operations involve choices about PodA Pod is a Kubernetes unit that runs one or more containers together. placement, nodeA node is a machine that runs containerized applications for a Kubernetes cluster. updates, isolation and scaling. The right setting depends on the workload and on how much capacity is available during changes.
How it works
- For Fargate placement, check that a profile selectorA Service selector chooses destination Pods by their labels. matches the Pod’s namespaceA namespace groups named Kubernetes resources within a cluster. and any specified labelsA label is a key-value attribute used to identify or select Kubernetes resources.. The profile uses private subnets without a direct route to an internet gateway. Fargate profiles and subnets
- For EBS storage, a StorageClassA StorageClass defines how Kubernetes storage is provisioned. selects the provisioner. Auto Mode uses
ebs.csi.eks.amazonaws.com; the standard EBS CSIThe Container Storage Interface connects Kubernetes volume operations to a storage driver. driver usesebs.csi.aws.com. They manage separate volumes. - Choose a managed node group update strategy. The default creates new nodes before terminating old ones. The minimal strategy terminates old nodes first, avoiding an increase in total capacity. A Pod disruption budgetA Kubernetes setting that limits concurrent voluntary disruptions to a workload. can block eviction; restrictive or overlapping budgets can cause
PodEvictionFailure. A forced update deletes Pods that do not leave within the eviction period. Update strategies and eviction and disruption budgets - For hardware isolation on supported EC2 instances, opt into isolated or confidential Pods with
runtimeClassName. Each Pod uses its own Nitro Sandbox. In Auto Mode, aSecurityGroupPolicyassigns security groups to selected Pods; unmatched Pods use the node security groups. Auto Mode useseks.amazonaws.com/v1, whose policy spec differs from the VPC CNIvpcresources.k8s.aws/v1beta1spec. Pod sandboxing, Auto Mode Pod security groups and policy comparison - Supply the Horizontal Pod Autoscaler (HPA) with metrics. Metrics Server provides CPU and memory resource metrics; adapters can expose custom or external metrics.
- For Cluster Autoscaler scale-down, compare requested resources with node capacity. A node below the utilization threshold is a candidate, while a Pod marked
cluster-autoscaler.kubernetes.io/safe-to-evict=falsecan prevent removal. For EBS workloads, use similar node groups per Availability Zone and enablebalance-similar-node-groups=true, because an EBS volume is limited to one zone. Scale-down parameters, Cluster Autoscaler and EBS volumes
Exam cues
- If the question says Fargate Pods remain Pending, think profile namespace, labels and private subnets, because the selector and subnet settings determine their placement.
- If the question says an update cannot add capacity, think the minimal strategy, because it terminates old nodes first.
- If the question says a node update fails with
PodEvictionFailure, think Pod disruption budgets, because restrictive or overlapping budgets can block eviction. - If the question says Pods on one node need hardware isolation, think isolated or confidential Pods, because each uses a Nitro Sandbox.
- If the question says Pods on one Auto Mode node need different security groups, think
SecurityGroupPolicy, because it assigns groups to selected Pods. - If the question says HPA must scale on queue depth, think an external metrics adapter, because resource metrics supply CPU and memory data.
- If the question says stateful Pods use EBS in different zones, think similar per-zone node groups, because each volume is limited to one Availability Zone.
Remember
- Managed node updates default to one unavailable node, with a maximum of 100 in parallel.
- Pod eviction can fail after 15 minutes; forcing the update deletes Pods that have not left.
- Cluster Autoscaler’s default utilization threshold is 0.5 of requested resources divided by capacity; its default unneeded time is 10 minutes.
- Nitro Sandboxes for EKS Pods and Auto Mode Pod security groups were announced in November 2026. Both require Kubernetes 1.36 or later. Nitro announcement and Auto Mode announcement
Trap: A node below the Cluster Autoscaler utilization threshold is only a scale-down candidate. The unneeded time and a Pod’s safe-to-evict annotationConfiguration metadata attached to a Kubernetes resource and interpreted by a controller. can affect removal. Auto Mode and VPC CNI
SecurityGroupPolicyspecs are also incompatible.
From the AWS docs (17)
- Fargate profile selectors require a namespace and can include labels; a Pod matching a selector can run on Fargate.
- EKS Fargate Pods use private subnets without a direct route to an internet gateway.
- A StorageClass selects how storage is provisioned; Auto Mode uses ebs.csi.eks.amazonaws.com, while the standard EBS CSI driver uses ebs.csi.aws.com and manages separate volumes.
- Managed node group default updates create new nodes before terminating old nodes; minimal updates terminate old nodes first to avoid increasing total capacity.
- If Pods do not leave a node within 15 minutes, a managed node update fails with PodEvictionFailure unless forced; force deletes the Pods.
- Restrictive or overlapping Pod disruption budgets can cause PodEvictionFailure during a managed node group update.
- Managed node group updates default to one unavailable node and allow a maximum of 100 nodes unavailable in parallel.
- EKS isolated and confidential Pods use individual Nitro Sandboxes on supported EC2 instances with Kubernetes 1.36 or later; runtimeClassName selects the opt-in mode.
- AWS announced Nitro Sandboxes for EKS Pods in November 2026.
- EKS Auto Mode security groups for Pods use SecurityGroupPolicy to assign different security groups to Pods on the same node; unmatched Pods use node security groups.
- EKS Auto Mode added security groups for Pods in November 2026 for Kubernetes 1.36 or later.
- Auto Mode SecurityGroupPolicy uses eks.amazonaws.com/v1 and is not spec-compatible with the VPC CNI SecurityGroupPolicy in vpcresources.k8s.aws/v1beta1.
- HPA requires a metrics source such as Metrics Server; resource metrics provide CPU and memory data, while adapters can expose custom or external metrics.
- The default Cluster Autoscaler scale-down-utilization-threshold is 0.5, based on requested resources divided by capacity; being below it makes a node a candidate for scale-down.
- The default Cluster Autoscaler scale-down-unneeded-time is 10 minutes.
- A Pod annotated cluster-autoscaler.kubernetes.io/safe-to-evict=false can prevent its node from being scaled down.
- EBS volumes are limited to one Availability Zone; AWS recommends balancing similar per-zone node groups for these workloads with balance-similar-node-groups=true.
Flashcards
Nothing to review here right now. Pick other topics or another filter.
·
All 61 cards as a list
Does Amazon EKS always manage only the control plane?
No. Standard EKS manages the control plane; Auto Mode also manages compute and infrastructure integration. Managed node groups still require you to deploy patched node images.
An EKS team needs GPU workloads and a privileged node agent. Should it choose Fargate?
Use suitable EC2 nodes. Fargate supports neither GPUs nor privileged containers nor DaemonSets.
An EKS team disables public API access. Where must its kubectl client run?
Inside the cluster VPC or a connected network, with access allowed by the cluster security group. Public access CIDRs do not grant private endpoint access.
An EKS application on Fargate needs persistent file storage. Can it mount an EBS volume?
Use a statically provisioned EFS persistent volume. Fargate cannot mount EBS volumes and does not support EFS dynamic provisioning.
An EKS EBS persistent volume claim fails with UnauthorizedOperation. What should the team configure?
Give the EBS CSI driver an IAM role with EBS API permissions, associated through Pod Identity or IAM roles for service accounts. A storage request alone does not grant AWS permissions.
Kubernetes Secrets on an EKS cluster must be encrypted with a key the company controls and audits in CloudTrail. What should they configure?
EKS envelope encryption with their own customer managed KMS key. EKS already envelope-encrypts API data with an AWS owned key by default.
A company wants to see its on-premises Kubernetes clusters next to its EKS clusters in the EKS console. What feature does that?
Amazon EKS Connector, which registers the external clusters for viewing in the console.
How do EKS Pod Identity and IAM roles for service accounts differ for workload permissions?
Both associate a workload role with a service account. Pod Identity uses the node agent and trusts
pods.eks.amazonaws.comwithout a cluster OIDC provider. IRSA uses OIDC and STS web identity. Pod Identity supports Linux EC2 Pods, not Fargate.An EKS application needs a rolling release, replacement replicas, and an external TCP endpoint. What should the team configure?
Use a Deployment with readiness probes and a LoadBalancer Service managed by the AWS Load Balancer Controller. The Deployment maintains replicas; the Service gets an NLB.
An EKS Pod is temporarily busy but should not restart. Which probe should stop new Service traffic?
A readiness probe. Failed readiness removes the Pod from Service traffic until it recovers.
An EKS application takes a long time to initialize and keeps failing liveness checks. What should the team add?
A startup probe. Readiness and liveness checks wait until it succeeds.
What do maxUnavailable and maxSurge control in an EKS Deployment?
maxUnavailablelimits unavailable Pods, with a default of 25%.maxSurgelimits extra Pods above the desired replica count.An EKS application version fails after rollout. Which kubectl operations inspect and revert the release?
Use
kubectl rollout history deploymentto inspect history andkubectl rollout undo deployment <name>to roll back.Should EKS liveness probes fail whenever a shared external database is unavailable?
Avoid that dependency. All replicas can fail together, causing repeated restarts without fixing the database.
A CI role assumes successfully but kubectl against an EKS cluster returns Unauthorized. What is missing?
A mapping of that IAM role to Kubernetes permissions: an EKS access entry (or the aws-auth ConfigMap).
What AWS load balancers does the AWS Load Balancer Controller create for EKS Service and Ingress resources?
An NLB for a Service of type LoadBalancer and an ALB for an Ingress. The controller must own the resource; the legacy provider has different behavior.
An EKS application must expose TCP and UDP traffic through an AWS load balancer. Which Kubernetes resource fits?
A controller-managed Service of type LoadBalancer, which creates an NLB for Layer 4 traffic.
An EKS application on Fargate must receive HTTP traffic through an ALB. Which target mode should its Ingress select?
IP targets using alb.ingress.kubernetes.io/target-type: ip. Fargate requires Pod IP targeting rather than instance targeting.
How does EKS instance target mode differ from IP target mode?
Instance mode sends traffic through node NodePort and Kubernetes forwarding. IP mode sends traffic and health checks directly to Pods.
An EKS ALB cannot be provisioned with only one eligible subnet. What subnet requirement is missing?
At least two subnets in different AZs, each with at least eight available IP addresses.
The EKS AWS Load Balancer Controller cannot discover internal load balancer subnets. Which discovery configuration should be checked?
The private subnet tag kubernetes.io/role/internal-elb: 1, or explicit subnet IDs on the Kubernetes resource. Public auto-discovery uses kubernetes.io/role/elb: 1.
An EKS rolling update removes old Pods before new Pod targets become healthy on the AWS load balancer. What coordinates these states?
A Pod readiness gate tied to load balancer target health. With IP targets it can keep the Pod unready until target registration and health checks complete.
An EKS Service of type LoadBalancer creates a Classic Load Balancer. Does that prove the AWS Load Balancer Controller selected a Classic type?
No. The legacy cloud-provider controller creates Classic Load Balancers by default. The AWS Load Balancer Controller creates NLBs for these Services.
An EKS application on Fargate needs AWS API permissions. Should it use Pod Identity or its Pod execution role?
Use IAM roles for service accounts for application permissions. Pod Identity does not support Fargate, and the Pod execution role is for infrastructure operations such as image pulls.
An EKS team runs one application in several clusters and wants to reuse its Pod Identity role. What must it configure?
Create a role association for the application service account and namespace in each cluster. The role trusts
pods.eks.amazonaws.com; no per-cluster OIDC trust update is needed.An EKS workload has a Pod Identity association but still uses old credentials. What should the team inspect?
Check the AWS SDK version and credential provider chain. Credentials located earlier in the chain take precedence over Pod Identity.
Does an EKS Auto Mode cluster require a separate Pod Identity Agent installation?
No. Auto Mode includes the agent; standard clusters need it configured on their nodes.
Does assigning EKS Pod Identity by itself stop a Pod from retrieving the EC2 node role?
No. Restrict access to EC2 Instance Metadata Service as well, so Pods cannot retrieve node-role credentials.
An EKS Pod needs to read an S3 bucket in another AWS account without application-managed role chaining. How can EKS Pod Identity provide the credentials?
Configure a same-account association role and a target role in the bucket account. Allow the first role to assume the target and configure the target's trust and S3 permissions.
An EKS Pod Identity association needs a session policy to limit a shared IAM role. What setting is required, and can the policy add permissions?
Disable session tags. The session policy intersects with role permissions, so it only restricts access. With a target role, it restricts the target role.
An EKS Pod Identity association is updated but running Pods still use the old credentials. What should the team do?
Recreate the Pods for faster application of the change, or wait for cached credentials to refresh. Changing the association does not reset the cache.
An EKS Pod using an HTTP proxy cannot obtain Pod Identity credentials from the node agent. What proxy configuration should be checked?
Exclude 169.254.170.23 and fd00:ec2::23 using no_proxy or NO_PROXY so agent requests bypass the proxy.
Can an EKS Pod with hostNetwork true be prevented from reaching the node IMDS merely by enabling Pod Identity?
No. hostNetwork Pods always have IMDS access, even though supported SDKs and the CLI use Pod Identity credentials when enabled.
An EKS Pod Identity Agent on a private node cannot obtain credentials from EKS Auth. Which node permission and network endpoint should be checked?
Grant eks-auth:AssumeRoleForPodIdentity to the node role and provide an EKS Auth interface endpoint for private access.
An EKS Pod Identity Agent fails to start on nodes with IPv6 disabled. What configuration change should be checked?
Disable the agent's IPv6 configuration. It listens on both IPv4 and IPv6 by default.
Which autoscaling components change EKS Pod counts and node capacity?
HPA changes Pod replicas. Cluster Autoscaler changes Auto Scaling group desired capacity. Karpenter provisions compute for workload requirements. Auto Mode builds on Karpenter and manages node scaling and consolidation.
An EKS HPA adds replicas but the Pods remain unschedulable. What should the team check?
Check resource requests and node scheduling requirements against available node-group capacity. HPA does not add nodes; a node autoscaler must be able to create capacity that fits those Pods.
Does an EKS cluster need a separately managed Karpenter installation to get Auto Mode compute scaling?
Auto Mode provides managed compute scaling built on Karpenter, including provisioning nodes for Pods that do not fit and consolidation.
Which diagnostic views help investigate an EKS Pod that does not start?
Use kubectl get pods to locate the state, kubectl describe pod for events, and kubectl logs for startup errors.
An EKS monitoring-agent Pod remains Pending and its events report FailedScheduling. What should an operator inspect before adding nodes?
Check CPU and memory requests, node capacity, nodeSelector, and tolerations. Incompatible placement constraints can block scheduling even with more nodes.
An EKS Pod reports ImagePullBackOff for an ECR image. Which checks distinguish image access from application startup?
Check the image tag and ECR reachability, then the EC2 node role or Fargate execution role used for pulling images. The container has not successfully obtained its image.
An EKS monitoring-agent Pod reports CrashLoopBackOff. What evidence should an operator inspect?
Container logs and Pod events. AWS identifies invalid configuration and missing mounts as possible agent startup causes.
An EKS team expects scheduler diagnostics in CloudWatch Logs, but never enabled control-plane logging. What must change?
Enable the scheduler log type for that cluster. Control-plane export is off by default and each type is enabled separately.
An EKS team must identify who changed cluster resources. Which log type and destination apply?
Enable audit logs and read /aws/eks/<cluster-name>/cluster in CloudWatch Logs in the same account.
An EKS workload cannot authenticate using IAM credentials. Which control-plane log type is relevant, and does enabling api enable it too?
Use authenticator logs. Each type is enabled individually, so enabling api does not also enable authenticator.
How do rolling updates and canary releases differ for EKS Deployments?
Rolling updates replace Pods using
maxUnavailableandmaxSurge. A canary runs a separate new Deployment with a small traffic share and uses additional routing or rollout tooling.An EKS team wants to test a complete replacement version before switching live traffic. What deployment pattern fits?
Blue/green. Create a separate Deployment, test it, then change the Service selector to the new version. Keep the old version for rollback.
An EKS team wants a small user population to try a release before wider exposure. What should it configure?
A canary release with a smaller new Deployment and controlled traffic routing. Increase traffic and replicas only after examining metrics.
An EKS canary shows unacceptable behavior. What traffic action provides rollback?
Stop sending traffic to the canary and route it to the old Deployment.
Does reducing maxSurge give an EKS release a controlled canary traffic percentage?
No.
maxSurgelimits extra Pods during a rolling update. A canary needs a separate Deployment and control over traffic routing.EKS Fargate Pods remain Pending after a profile is created. What selection settings should the team check?
Check that the Pods match a profile selector namespace and any required labels, and that the profile uses private subnets.
Which EKS StorageClass provisioners distinguish Auto Mode EBS storage from the standard EBS CSI driver?
Auto Mode uses
ebs.csi.eks.amazonaws.com; the standard driver usesebs.csi.aws.com. They manage separate volumes.An EKS managed node group has scarce GPU capacity and cannot temporarily add nodes during an update. Which update strategy fits?
Use the minimal strategy, which terminates old nodes before creating replacements. The default strategy creates replacements first to maintain capacity.
An EKS managed node group update fails with PodEvictionFailure because a Pod disruption budget blocks eviction. What should the operator consider?
Review the budget and workload availability before retrying. A forced update deletes Pods if eviction cannot complete within 15 minutes.
What is the default maximum unavailable node count during an EKS managed node group update?
One node. The configured maximum unavailable is capped at 100 nodes.
An EKS application requires hardware isolation between Pods sharing an EC2 node. What option provides this on supported instances?
Use isolated or confidential Pods with the appropriate runtimeClassName. Each runs in a Nitro Sandbox; Kubernetes 1.36 or later is required.
An EKS Auto Mode cluster needs different security groups for Pods sharing one node so only selected workloads can connect to an RDS database. What should the team configure?
Use an Auto Mode SecurityGroupPolicy selecting those Pods. Unmatched Pods keep node security groups. This feature requires Kubernetes 1.36 or later.
Can an EKS team reuse a VPC CNI SecurityGroupPolicy manifest unchanged for EKS Auto Mode Pods?
No. Auto Mode uses eks.amazonaws.com/v1 and its policy spec differs from the VPC CNI vpcresources.k8s.aws/v1beta1 resource.
An EKS team wants replicas to scale from queue depth. What does HPA need?
An external metrics source exposed through an appropriate metrics API adapter, plus an HPA configured for that metric. CPU Metrics Server data alone does not supply queue depth.
An EKS node is below 50% requested utilization. Must Cluster Autoscaler delete it immediately?
No. The default 0.5 threshold makes it a candidate. The default unneeded time is 10 minutes, and a Pod marked
cluster-autoscaler.kubernetes.io/safe-to-evict=falsecan prevent removal.EKS stateful Pods use EBS volumes in different Availability Zones. What node-group design helps Cluster Autoscaler place them?
Use similar node groups scoped to individual Availability Zones and enable
balance-similar-node-groups=true, because an EBS volume is tied to its zone.