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.

Docker introduces a container-based solution to traditional infrastructure, packaging applications with their libraries and dependencies for consistent, portable deployment across development, staging, and production environments.

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.

Create and compare AWS Fargate and EC2 Linux clusters, enabling CloudWatch container insights, configuring VPC, subnets, security groups, and on-demand vs spot provisioning.

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.

Create a Fargate task definition for Enginex app by configuring the Docker image, memory and CPU, and adding a container definition with port 80.

Create a fargate service named enginex app1 svc in the fargate demo cluster using enginex app1 td latest, running one task with a public IP, accessible at /app1/index.html.

Run a new task on Fargate using the Nginx app 1T1 task definition in the cluster with subnets 1A and 1B, auto-assign public IP, and the task execution role.

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.

Create an ECS task definition and a Fargate service using the ECR nginx image, then deploy and test by accessing the service via its public IP.

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 and test two Nginx-based docker images for load balancing and autoscaling, building app one and app two, then push to Docker Hub for the upcoming application load balancer setup.

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.

Create an EC2 Linux ECS cluster and deploy Enginex App2 as a two-task replica service behind an application load balancer, with one task per host and /app path routing.

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.

Explore continuous integration, delivery, and deployment workflows across source, build, test, and production stages using AWS tools like code commit, code build, code pipeline, code deploy, fargate, and cloudwatch.

Create staging and production ECS Fargate services from a task definition, using a container named ECS CI CD enginex and reference it in the buildspec.yml to enable CI/CD testing.

Explore AWS CodeCommit as a private version control service for code, documents, and binaries, and learn to generate static git credentials via IAM for CI/CD workflows from a local repository.

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.

Create a buildspec.yml for CodeBuild to build and push Docker images to ECR, tag images with the commit ID, and update ECS task definitions.

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

Create a codepipeline for ecs deployments, update codebuild to push images to ecr, and test via the static html page, enabling end-to-end ci cd for nginx in ecs.

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.

Create a deploy to prod ECS service stage in CodePipeline, configuring prod deployment with EKS, input artifacts, and image definitions while enabling manual approvals for staging and production.

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.

Introduces two microservices, user management and notification, deployed on ecs and fargate, detailing APIs, the users database, health checks, and service discovery with or without a load balancer using ses.

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.

Verify the notification microservice is running, confirm target group health checks pass, and ensure inbound port 8096 is open; then check the health at the load balancer /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.

Update the RDS security group to allow the user management service to access the MySQL database on port 3306 by adding the service's security group as the inbound source.

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.

Discover how service discovery enables direct communication between microservices using AWS Cloud Map and Route 53, replacing the load balancer with DNS names like notification.apps.local or notification.microservices.local for improved performance.

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.

Configure a notification microservice with service discovery in ECS Fargate, creating a private cloud map namespace, task definitions, and dns records for reliable inter-service communication.

Update the user management microservice task definition to call the notification service via service discovery. Test with Postman to verify emails are delivered using the service discovery name.

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.

Create internet-facing application load balancer for microservices app mesh in X VPC South, using IPv4 on port 80, with target group and Route 53 alias app mesh dot stack simplify.com.

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 a user management microservice with service discovery on Fargate, configure App Mesh integration, a load balancer, health checks, and test user creation with email via simple email service.

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.