AWS Copilot

AWS Copilot is an opinionated CLI tool that helps developers deploy containerized applications to AWS App Runner, Amazon ECS, and AWS Fargate with minimal configuration. In this lesson, we’ll focus on how Copilot works with ECS, as AWS App Runner is out of scope for this exam.

Copilot eliminates the need to manually set up infrastructure by generating and managing AWS CloudFormation templates behind the scenes. This significantly simplifies the process of defining and operating cloud-native microservices.

Designed to support Amazon ECS on both Fargate and EC2, Copilot is especially effective when paired with Fargate’s serverless compute model, which abstracts away server management tasks. While ECS on EC2 is still supported for advanced customization, most users will benefit from Fargate’s streamlined deployment experience.

From a developer’s perspective, AWS Copilot offers several advantages:

• It creates consistent, production-ready infrastructure using proven AWS architectural patterns.

• It accelerates deployment with high-level commands that encapsulate best practices.

• It reduces manual configuration by handling IAM, networking, logging, monitoring, and deployment strategy setup automatically.

Copilot allows us to focus on writing code, not infrastructure. It supports real-world workflows such as environment separation (e.g., dev, test, prod), CI/CD integration, and safe deployments with rollback. The illustration below shows how deployments are managed using Copilot.

Before exploring the application lifecycle, it’s helpful to understand the main components of AWS Copilot.

Core components of AWS Copilot

The main components that Copilot uses to structure and manage applications are as follows:

• Application: It is a top-level logical construct that represents the entire deployment context for the project. It groups related services and jobs under a single namespace and allows shared configuration across environments. Each application maps to an AWS CloudFormation StackSet and manages metadata, enabling centralized resource tracking and organizational consistency.

• Manifest: It is a YAML file that describes the configuration of a service or job. It defines container port mappings, CPU/memory limits, environment variables, auto scaling policies, secrets, and health checks. Manifests are version-controlled, environment-aware, and drive the behavior of Copilot deployments.

• Service: It is a containerized workload that is continuously running, often representing user-facing functionality such as an API or web frontend. Services are automatically deployed behind load balancers when needed, configured with auto scaling, and integrated with logging and health checks. Each service has its own manifest file to specify runtime behavior.

• Job: It is a task that runs to completion and then exits. Jobs are suitable for batch processing, scheduled data workflows, or one-off initialization scripts. Jobs can be scheduled using cron expressions and can interact with other AWS services like S3, DynamoDB, or EventBridge.

• Environment: It is a self-contained deployment target that includes its own networking stack (VPC, subnets, and NAT gateways), IAM roles, and service discovery namespace. Copilot environments are explicitly defined, like dev, test, prod, and allow for isolated deployments with environment-specific configuration and security boundaries.

• Pipeline: It is a CodePipeline configuration automatically generated and deployed by Copilot to support CI/CD. The pipeline integrates with Git repositories, builds container images with CodeBuild, and deploys them through one or more Copilot ...