AWS Fargate & ECS - Masterclass | Microservices, Docker, CFN

Master the ECS objects—task definition, container definition, service, and cluster—and learn how Fargate uses a blueprint to run one or more containers with a serverless, isolated boundary.

Create your first fargate cluster using the ecs get started flow; configure a nginx task, service, and cluster in a vpc, then deploy and access via http on port 80.

Explore how a Fargate ECS cluster creates a service and tasks, access the Nginx app via its public IP, scale tasks from 1 to 3, and observe automatic task recovery.

Apply step three tips to save costs during learning by keeping running tasks zero. Update the Enginex service to zero tasks and verify no running tasks in the Fargate cluster.

Explore docker fundamentals, including what docker is, its architecture and terminology, and how to pull and run images, build and push containers, with installation tips and essential commands.

Master Docker architecture and terminology, including hosts, daemon, client, images, and containers, and learn to pull, run, build, and push via Docker Hub and private registries.

Learn to install docker on Windows and macOS with Docker Desktop or engine, meet system requirements, run hello world, and fix macOS keychain cred store by editing config.json.

Pull a docker image from docker hub, run it as a container locally with the docker intro springboot hello world rest api image, and map 8080 to 80 for localhost/hello.

Build a custom nginx image locally from a dockerfile and index.html, run it to test, then tag and push the image to docker hub.

Explore essential Docker commands to manage containers and images, including listing, stopping, starting, removing, pulling images, connecting to containers, and viewing stats, processes, and version.

Learn how to create and manage Fargate and ECS clusters, define tasks, and deploy services using Fargate serverless and EC2 launch types, while exploring VPC setups.

Create a dedicated vpc with IPv4 block 10.0.0.0/16, two public subnets in ap-south-1, and attach an internet gateway with a default route 0.0.0.0/0 for the next fargate cluster setup.

Explore cluster features for Fargate and ECS, including services, tasks, and capacity providers. Leverage Cloudwatch container insights for metrics and schedule long-running stateless tasks.

Learn how to define Amazon ECS task definitions for Fargate and EC2, detailing task size, container definitions, networking, roles, logging, and key parameters.

Learn to revise ECS objects, manage rolling deployments, load balancing, and auto scaling, and shift image sources from Docker Hub to Amazon ECR.

Learn to integrate Elastic container registry (ecr) with AWS fargate and ecs to store, manage, and deploy docker images securely and at scale.

Understand ECR terminology including registry, repository, repository policy, and authorization token, and learn prerequisites: install AWS CLI and Docker CLI, configure AWS access keys and default region.

Learn to create an AWS ECR repository using both the management console and CLI, enable tag immutability and scan on push, note the repository URI, and push Docker images.

Build a local docker image from a custom nginx setup, test it locally, then push the image to AWS ECR with vulnerability scanning.

Learn to implement load balancing and autoscaling for Fargate and EKS with a single application load balancer that routes two nginx apps, builds tasks and scales automatically.

Create an application load balancer for ecs fargate, wire it to a vpc with public subnets, open port 80, and define a temp TG for /app1 and /app2 routes.

Create task definitions for Enginex app one on Fargate and Enginex app two on EC2 Linux, using stack simplify Enginex app one and stack simplify Nginx app two.

Learn to create a Fargate-based ECS service for Enginex app one using the Fargate demo cluster, including load balancer integration, target group configuration, and health check grace period settings.

Implement target tracking autoscaling for an ECS service using ELB request count per target, set a min of 2, max of 3 tasks, and configure 60-second scale-out/in cooldown.

Launch an EC2 ApacheBench instance to generate load and test ECS autoscaling with a target tracking policy, observing task scaling from one to three and CloudWatch metrics.

Discover how step scaling policy extends auto scaling beyond target tracking by using custom CloudWatch alarms and up to 86 ECS metrics from Container Insights to trigger actions.

Clean up load balancing and autoscaling resources in ECS and Fargate by zeroing tasks, removing scaling policies, deleting services and clusters, and terminating Apachebench.

Create a CodeCommit repository named CI CD Enginex, clone it locally, configure git credentials, add a dockerfile and index.html, then commit and push to CodeCommit.

Explore AWS CodeBuild, a managed build service that compiles code, runs tests, and outputs artifacts. Use buildspec.yml to drive builds from sources, store artifacts in S3, and log to CloudWatch.

Learn how AWS CodePipeline models, visualizes, and automates software releases with source, build, deploy, and monitor stages, plus staging and production via manual approvals.

Deploy v2 by updating index.html, committing, and pushing, then monitor the CodePipeline as it builds, deploys to staging, and tests with the public IP and image definitions.

Create a manual approval stage in CodePipeline, configure an SNS email topic and subscription, and ensure production deployment proceeds only after the approver confirms.

Explore microservices architecture and learn how to deploy them on AWS Fargate or ECS with and without service discovery, then apply AWS App Mesh and canary deployments.

Create a MySQL RDS database for the user mgmt service, in the VPC, and capture endpoint and port 3306 for container environment variables.

Create smtp credentials in AWS SES and configure the notification service to send emails via the SES smtp server, with verified from addresses and the smtp endpoint and port 587.

Create an internet-facing application load balancer for the ECS VPC, enable port 80, and alias it in Route 53 as services.stack.simplify.com, using auto-registered ECS tasks.

Create a Fargate task definition for the notification microservice in ECS, with 2 gb memory, 1 cpu, image notifications-microservice:1.0.0, port 8096, and smtp credentials.

Create the notification microservice as a dedicated ECS service using its task definition, exposing ports 8095 and 8096 behind the application load balancer and health path notification/health status.

deploy the user management microservice by creating the Fargate task definition and service, configuring image, port 8095, and environment variables for MySQL and the notification service.

Create the user management microservice SVC user management microservice on ECS Fargate, configure the application load balancer and target group, and verify health checks.

Import the postman collection for the two microservices, update the environment URL, and test user management and notification flows by creating users and sending emails.

Identify the drawbacks of a two-microservice setup where the user management service calls the notification service over the internet, and present service discovery to enable direct, in-VPC communication between microservices.

Understand how the user management and notification microservices interact in development, including their rest APIs, configuration, and environment variables. Learn how user creation triggers a notification call.

Learn how AWS Cloud Map acts as a cloud resource discovery service, define namespaces and services, register healthy service instances, and enable client-side service discovery with dns names.

Increase the notification microservice tasks to four and verify Cloud Map and Route 53 records. Observe four service instances and understand the multi value answer routing used for load balancing.

Explore how Route 53 multi value routing in a private DNS zone enables service discovery for microservices without a load balancer, improving performance while cleaning up resources to zero tasks.

Deploy microservices with AWS App Mesh on ECS Fargate, use envoy proxies for communication, enable X-Ray tracing out of the box, and manage egress to RDS and Simple Email Service.

Register the notification microservice with service discovery on AWS Fargate, creating a private dns namespace and Cloud Map service for App Mesh, without public load balancing.

Create an app mesh with egress traffic enabled, allowing external services like MySQL and the simple email service to communicate with user management and notification services.

Create App Mesh virtual nodes and services for notification and user management, configure DNS discovery with HTTP ports, and update the task execution role with X-Ray, CloudWatch, and Envoy access.

Enable app mesh in the notification service task definition by adding the x ray daemon container, enabling envoy tracing and logging, and configuring outbound ports 587 (smtp) and 3306 (database).

Test and verify inter-service calls in a microservices setup using App Mesh and Envoy proxy, with Postman, X-Ray distributed tracing, and end-to-end visibility from user management to notification services.