Docker in AWS - Java Spring Boot to AWS Fargate & ECS [2020]

Create an AWS root account by entering your email and password, verifying your phone, and providing contact and billing details, then access the free tier and management console.

Create a developers IAM group with administrator access, add the in28minutes_dev user to it, and sign in using the IAM management console URL instead of the root account.

Get a 10,000-foot overview of cloud, AWS, containers, and container orchestration with ECS and AWS Fargate, including EC2 clusters, Docker tooling, microservices, and on-demand provisioning.

Deploy your first docker container on AWS Fargate using the ECS first-run wizard, creating a container, task definition, service, and cluster in US East North Virginia.

Launch the sample app by opening the running task's public IP in a browser, confirming the app runs on Amazon ECS with Fargate.

Define AWS ECS task definitions for containers on Fargate, detailing task name, container definitions, memory and CPU limits, port mappings, and the ecsTaskExecutionRole.

Create and configure an ECS service for the aws-hello-world-rest-api task on the aws-fargate-cluster using Fargate, configuring a VPC, subnets, and a security group to expose port 80.

Explore how an ecs service maintains a desired task count by running and replacing tasks, then launch and test the hello-world rest API in the browser.

Learn five practical strategies to monitor and minimize cloud costs in AWS. Set up billing alerts, monitor daily billing, and stop unused resources such as EC2 and Fargate workloads.

Set up AWS billing alerts and budgets to monitor costs, using CloudWatch alarms and the Budgets feature, with email notifications via SNS in US East North Virginia.

Set the number of tasks to zero in AWS Fargate to minimize running instances and reduce cloud bills, then scale up only when needed.

Learn how to launch an AWS Fargate task directly, compare it with running tasks under a service, and identify use cases for batch workloads.

Learn how to run a simple batch program as an ECS task using a task definition and Fargate, monitor logs in CloudWatch, and differentiate between running tasks and services.

Explore how ECS runs with EC2 instances versus AWS Fargate, including how EC2 virtual servers differ from serverless tasks, and observe how a service task runs without visible EC2 instances.

In us east north virginia, manually create an ecs-ec2 cluster using ec2 linux + networking and deploy three on-demand t2_micro instances.

Create and place ECS services on EC2-backed clusters across AWS regions and availability zones, using AZ balanced spread with subnets for multi-zone deployment of a hello world rest api.

Switch to host networking for the EC2 launch type by creating a new task definition with host mode and updating the service, so tasks are reachable via the host IP.

Learn how to scale EC2 instances in an ECS cluster, manage container and EC2 instances, and understand ECS terminology, including EC2, container, and ECS instances.

Learn to debug ECS and Fargate problems by inspecting service events, adjusting task counts, updating task definitions, and scaling EC2 instances when memory constraints prevent task placement.

Learn to debug ECS tasks by examining service events, revising task definitions with memory limits, enabling CloudWatch logging, and analyzing stopped reasons and exit statuses.

Terminate the ecs-ec2-cluster to minimize costs by deleting all tasks, services, and resources including VPCs and subnets via CloudFormation.

Compare ECS on EC2 and Fargate, covering cluster management, resource needs, and cost. Learn to choose Fargate for startups and EC2 for customization while deploying apps.

Explore microservices by defining small, rest-exposed, cloud-enabled services with independent deployability and well-defined boundaries, scalable via multiple instances and lightweight communication.

Explore bounded context to define microservice boundaries using domain driven design. Address configuration management, dynamic scaling with load balancing, and centralized visibility for fault tolerance.

Discover how microservice architectures enable adapting to new technology and processes, with services built in different technologies, enabling dynamic scaling and faster releases.

Import eight Maven-based microservice projects into Eclipse, using clone or download, unzip to a path, then load them as existing Maven projects for local runs, container builds, and ECS deployment.

Test the currency exchange microservice locally, build and test a Docker image, and deploy it to AWS Fargate and ECS, using Spring Boot, JPA, and an in-memory H2 database.

Build a Docker container for the currency exchange service using a Dockerfile and the dockerfile-maven-plugin. Run the image locally with port mapping and verify the endpoint.

Sign up for Docker Hub, update the pom.xml with your docker id, rebuild, and push the currency exchange image to Docker Hub using the 0.0.1-SNAPSHOT tag for ECS Fargate.

Create a task definition for the currency exchange service on AWS Fargate, configure 0.5 GB memory and 0.25 CPU, and deploy as a Fargate service with port 8000.

Deploy the currency exchange microservice on AWS Fargate, verify logs and status, and open port 8000 in the security group for EUR to INR conversion via a public IP.

Use ECS container metadata URI and RestTemplate to populate exchange environment info with container and task details, including private IP, via a container metadata service bean to identify responding instance.

Build container images for a hello world rest api and a spring task. Push to Docker Hub and deploy to AWS ECS Fargate, using mvn clean package and docker run.

Learn to use prebuilt container images from Docker Hub and GitHub, test and build locally, push to Docker Hub, then deploy from AWS Fargate and ECS with a fast-forward approach.

Explore switching the currency exchange service from h2 to mysql, configuring rds environment variables, pom.xml changes, and a commandline runner that seeds data for local and cloud testing.

Launch a MySQL database using the official mysql:5.7 Docker image, configuring root password, database, user, and password via environment variables. Publish port 3306 and connect with the MySQL shell client.

Connect the local currency exchange microservice to MySQL with Docker, run the app, and verify data at localhost:8000 before deploying to Docker Hub and AWS Fargate.

Build and push a MySQL-backed currency-exchange Docker image to Docker Hub using mvn clean package and a Dockerfile, tag 0.0.1-SNAPSHOT, for AWS Fargate.

Create a MySQL database on AWS RDS using the free tier, configure the instance, credentials, and initial database name, and connect it to the Fargate cluster VPC for high availability.

Create a Fargate task definition and service for aws-currency-exchange-service-mysql, configure port 8000 and RDS environment variables, then deploy on ECS with proper security settings.

Configure the default security group to allow MySQL traffic on port 3306 from the currency exchange service mysql task security group for ECS Fargate, and verify connections via CloudWatch logs.

Create and attach a dedicated database security group to the RDS instance, restricting inbound MySQL traffic to the currency exchange service task's security group.

Review and run the currency conversion microservice locally, connect to the currency exchange service, configure the URI via environment variables, and test on ports 8100 and 8000 before dockerizing.

Build and run the currency-conversion and currency-exchange services as docker containers, connect them on a shared docker network, and configure currency_exchange_uri to enable inter-service communication.

Push the currency conversion image to Docker Hub, create a Fargate ECS task definition, configure port 8100 and the currency exchange URI, and deploy with a public IP.

Deploy and test the currency conversion microservice on AWS Fargate, configuring task definitions and environment variables to enable communication with the currency exchange service.

Run both currency exchange and currency conversion in a single Fargate task, with the conversion service calling the exchange service on localhost:8000, and expose ports 8000 and 8100.

Deploy two microservices in the same task to enable fast communication and simplified deployment, then contrast with separate tasks to allow independent scaling for external customers.

Explore centralized configuration with AWS Parameter Store in Systems Manager by creating dev parameters for currency-exchange-service, including RDS name, hostname, and secured password, to enable scalable, secure app configuration.

Update the ECS task definitions to inject centralized configuration from AWS Systems Manager Parameter Store using ValueFrom ARNs, enabling runtime environment variables for the currency exchange service mysql.

Grant read-only access to AWS SSM Parameter Store for the ecsTaskExecutionRole, stop and relaunch tasks, and verify startup by checking CloudWatch logs and environment variables.

Master centralized configuration management with parameter store, configure services via environment-scoped parameters, and update deployments without editing task definitions.

Explore how AWS X-Ray enables end-to-end tracing of microservices, with code changes (xray-recorder-sdk-spring, AOP config, XRayEnabled on the currency exchange controller) and deploying the container to AWS.

Build a container image, push to Docker Hub, and deploy the currency exchange microservice on AWS Fargate; add an X-Ray daemon container and update the task definition.

Grant xray permissions to the ecs task execution role and attach xraydaemonwriteaccess, enabling the x-ray daemon to send trace segments and populate service maps and traces.

Enable aws x-ray tracing in the currency conversion service by wiring a rest template with the x-ray http client builder and aop filters for calls to the currency exchange service.

Enable x-ray on the currency conversion service to visualize traces and service maps with analytics, showing how currency conversion calls the currency exchange service and how to debug performance issues.