Deploying Java Spring Boot microservices on AWS ECS Securely

Create an elastic container registry repository for the loan microservice, login with AWS CLI, build and tag a Docker image via Maven, and push it to ECR for ECS deployment.

Understand virtual private cloud basics, including its IP range and the role of subnets, route tables, and NAT gateway, and distinguish private from public AWS services.

Subnets are divisions within a VPC IP range that assign IP addresses to resources like EC2 instances, illustrated by splitting 1–100 into subranges such as 1–20 and 21–40.

Understand route tables as security guards for VPC subnets, directing traffic between EC2 instances and the Internet gateway and NAT gateway.

Define NAT gateway as a network address translation gateway that enables outbound traffic from a private subnet and, with a route table and internet gateway, differentiates public and private subnets.

Understand why private subnets, route tables, and NAT gateway secure microservices by preventing direct internet access, while API gateway and VPC link connect to a private load balancer and ECR.

Create three private subnets across three availability zones in a VPC, with a private route table to block internet access, and configure a NAT gateway for ECR access.

Create a NAT gateway in a public subnet with an elastic IP, attach it to private subnets via a route table for outbound ECS traffic.

Store configuration data in the aws parameter store to securely and hierarchically manage parameters like database url, username, password, and port without redeploying; the application restarts to fetch latest values.

Update application.properties with parameter store placeholders and defaults to enable runtime property resolution, then rebuild and push updated docker images for loan and bank balance microservices to AWS ECR.

Create and organize hierarchical parameters in the AWS parameter store for dev, prod, and qa environments, including MySQL host, port, username, and password as a secure string.

Learn the elastic container service architecture, including ECS cluster boundaries, task definitions, Fargate vs EC2, containers, environment variables, replication, load balancing, service discovery, VPC, and deployment flow.

Create a security group for private microservices, configure inbound rules for ports 7070 and 7071 over IPv4 and IPv6, and apply it across load balancers and services for consistent accessibility.

Create IP-based target groups for bank and lone microservices in AWS ECS, use HTTP with actuator health checks at /actuator/health, and attach to a load balancer for ECS services.

Create an internal application load balancer in private subnets, map ports 7070 and 7071 to loan and bank microservices, with API gateway routing and parameter store setup.

Create an ECS cluster with AWS Fargate serverless, so containers are managed by AWS and the underlying infrastructure remains inaccessible; EC2 offers more control, but this course uses Fargate.

Create loan emis task definition on aws fargate with linux, configure cpu and memory, assign ecs task execution and ecs service roles, set container image from ecr, map port 7070.

Create the loan microservice ecs service by selecting the latest task definition revision, deploying with fargate in private subnets, and attaching a load balancer and security group.

Create a VPC link for HTTP APIs to privately connect API gateway with the application load balancer using private subnets, ENIs, and security group ports 7070 and 7071.

Create an api gateway, set up http api, and configure routes for bank and loan microservices using proxy plus, enabling unified routing across containers.

Learn to configure VPC integration with API gateway using VPC links, implement parameter mapping to strip dev paths, and route to loan and bank microservices behind a load balancer.

Enable and view logs for ECS services and API Gateway via CloudWatch, create log groups, enable auto deployment, configure JSON-formatted logs, and monitor log streams for health.

Discover why service connect and service discovery are essential for microservices, showing how a loan service uses a common name to locate the bank balance service in containerized AWS deployments.

Explore how AWS ECS service connect and service discovery enable a loan microservice to find and call bank microservices, using a service connect agent and a shared namespace.

Enable service connect on the bank balance microservice, configure namespace, port alias 7071, and DNS so the loan microservice can discover and call bank balance.

Enable service connect for the bank microservice by creating a namespace and using API calls for instance discovery, then roll out a service connect agent beside the loan microservice.

Store the loan service configuration in parameter store, update the task definition environment variables with the arn, and redeploy the latest revision to enable calls to the bank balance microservice.

Test service connect and service discovery by issuing loan requests (amounts 1000 and 2000) and verifying bank balance calls, and confirm loan objects are created and approved in the database.

Explore auto scaling for Java Spring Boot microservices on AWS ECS, using CPU and memory thresholds with CloudWatch alarms to scale containers up or down based on requests per minute.

Configure service auto scaling for the loan microservice by setting minimum and maximum tasks and using target tracking with a three-request target and 30-second scale out and scale down cooldowns.

Configure auto scaling for ECS with target tracking. Set min 2 tasks, max 4; scale out on >3 requests over 3 minutes, scale in below 2.7.

Explore how AWS automated developer tools enable scalable deployment pipelines, covering code commit, code build, continuous integration, continuous delivery and deployment with CodePipeline, ECR, Docker images, and ECS.

Switch to GitHub as the source control after CodeCommit discontinued new customer support, then configure CodeBuild and CodeDeploy to deploy Java Spring Boot microservices on AWS ECS.

Set up AWS CodeBuild for Java Spring Boot microservices by connecting GitHub with the AWS managed app, selecting the main branch, and enabling automatic rebuild on pushes.

Configure the on-demand environment with Linux Amazon Linux and a new service role for loan microservice, then set up a buildspec.yml to build and push a Docker image to ECR.

Grant CodeBuild the necessary permissions to push Docker images to Amazon Elastic Container Registry by attaching the power user policy to the build project's service role.

Create a custom aws codepipeline to automate loan microservice deployment from GitHub main through codebuild to ecs, with s3 artifacts, webhook triggers, and automatic retries.

Push a code change to the loan service to update the health message, trigger the automated deployment pipeline, and verify the new string appears in the health endpoint after deployment.