The orchestration of containers (for example, Amazon ECS, Amazon EKS)

Task Statement 3.2: Design high-performing and elastic compute solutions.

Containers are a way to package your applications with everything they need to run: code, libraries, configuration, and dependencies.

Think of a container as a self-contained unit that can run anywhere without worrying about the environment.
Common container format: Docker.

Portability: Works the same on a developer’s laptop, staging, or production server.
Isolation: Each container is independent; apps don’t interfere with each other.
Efficiency: Multiple containers can run on the same server without wasting resources.

When you have many containers, managing them manually becomes impossible. You need automation for:

Container orchestration is the process of managing all these tasks automatically.

AWS provides two main container orchestration services for the exam:

Type: AWS-native orchestration service
Mode: Can run on EC2 instances (you manage the servers) or Fargate (serverless, no server management)
Key Features:
- Task Definition: Blueprint for containers (CPU, memory, image, environment variables)
- Service: Ensures the desired number of container instances are always running
- Cluster: Group of container instances (EC2 or Fargate)
- Load Balancing: Integrates with ALB to distribute traffic
- Auto Scaling: ECS can scale tasks automatically based on CPU, memory, or custom metrics

When to use ECS:

Type: Managed Kubernetes service
Kubernetes: Open-source container orchestration system used worldwide
Key Features:
- EKS runs Kubernetes control plane for you
- You manage worker nodes (or use Fargate for serverless nodes)
- Supports advanced features like:
  - Multi-container pods
  - Complex networking
  - Custom resource definitions
- Autoscaling via Kubernetes HPA (Horizontal Pod Autoscaler)

When to use EKS:

When you need multi-cloud or hybrid-cloud portability
If your team is already familiar with Kubernetes
When you need advanced orchestration features like multi-container pods or complex deployment strategies

Concept	ECS	EKS
Managed Control Plane	Yes	Yes
Serverless Option	Fargate	Fargate
Scaling	ECS Service Auto Scaling	Kubernetes HPA / Cluster Autoscaler
Deployment Type	ECS Tasks & Services	Pods & Deployments
Integration	AWS-native (CloudWatch, ALB, IAM)	AWS + Kubernetes ecosystem

In IT environments, containers are commonly orchestrated for:

Web Applications: Multiple containers running frontend, backend, and database connections with ECS or EKS
Batch Jobs: Containers running scheduled tasks, like log processing or data transformation
Microservices Architecture: Each service in its own container; orchestration handles scaling and networking
CI/CD Pipelines: Containers run automated builds and tests; orchestration manages parallel execution and resource optimization

Remember ECS is AWS-native, EKS is Kubernetes-based.
Serverless container deployment in both is via Fargate.
ECS is simpler; EKS is more flexible but complex.
For high availability, both integrate with Elastic Load Balancers and Auto Scaling.
Know the components: Cluster → Service → Task (ECS), and Cluster → Pod → Deployment (EKS).

Containers: “Apps in a box that run anywhere”
Orchestration: “The manager that tells containers when to start, stop, and scale”
ECS: AWS does everything for you (simpler, integrated)
EKS: Kubernetes standard (more control, complex, multi-cloud)
Fargate: Serverless option — no servers to manage