Deploy Fargate ECS Apps & Infrastructure: AWS with Terraform

Install the AWS CLI on Linux using apt-get, configure credentials, and verify with aws --help.

Configure the AWS CLI by entering your access key, secret key, and a default region. Set the output format to json, and prepare your environment for Terraform deployments.

Install Docker on Windows 10 professional or enterprise 64-bit by choosing Docker Desktop for Windows or Docker Toolbox, then enable virtualization in BIOS to run VirtualBox and complete setup.

Install TerraForm on macOS using homebrew, upgrade to the latest version, test the installation, then install the TerraForm plugin in IntelliJ with HashiCorp TerraForm language support.

Install the AWS CLI on macOS using Homebrew to configure access keys and secret keys for command-line access to AWS resources; cover pip and package installation options and test setup.

Create a Terraform project in the ecs_fargate directory, add main.tf and variables.tf, and set up the workspace for deploying Fargate ECS apps. Open the project in IntelliJ and start development.

Define the Terraform remote state backend for the infrastructure layer. Create infrastructure-prod.config and configure the x-fargate-terraform-remote-state bucket in eu-west-1 to enable backend state sharing.

Create a production VPC on AWS using Terraform, define region and cidr block as variables, set an S3 backend, enable DNS hostnames, and tag the VPC.

Create private subnets in AWS using Terraform, defining CIDR blocks, availability zones (EU West 1A, 1B, 1C), and names for three subnets, with plans to add route tables.

Create a public route table in AWS with Terraform, naming it public-route-table and tagging it as public route table, then preview the upcoming private route table video.

Associate public and private subnets with route tables using Terraform, referencing route table IDs and subnet IDs for multiple subnets, and outline elastic IP, NAT gateway, and internet gateway.

Create an elastic ip for a nat gateway in your vpc to enable private subnet egress to the internet for updates and content without inbound access.

Create a nat gateway using an elastic ip, attach it to a public subnet, and link it to a private route table with a 0.0.0.0/0 route to access the internet.

Create an internet gateway in your production VPC and add a public route to the public route table, enabling resources to access the internet via Terraform.

Create an AWS ECS cluster using Terraform by defining an AWS ECS cluster resource and naming it production Fargate cluster.

Create an internet-facing application load balancer for an ECS cluster with Terraform, configure its security group, and reference VPC and subnets from remote state.

Create an AWS ACM domain certificate and validate it via DNS for your ECS cluster load balancer. Use Terraform in domain.tf with Route 53 records and wildcard domain support.

Create a default ECS target group for the application load balancer; route traffic to subdomains, name it with the cluster and TGW suffix, set port 80 http, and tag.

Create an IAM role for the ECS cluster to access AWS services such as S3 and autoscaling, and configure an inline JSON assume-role policy in Terraform.

Create and attach an inline IAM policy to the ECS cluster role, granting access to EC2, ECR, CloudWatch, S3, and other services via a JSON policy.

Execute terraform to provision a multi-layer AWS platform and output remote state values like VPC ID, VPC CIDR, EKS cluster, ALB listener, domain name, and subnets, then apply the plan.

Deploy a simple Spring Boot application to AWS Fargate, focusing on the infrastructure surrounding the app, including server port configuration and health and metrics endpoints, built with Maven.

Configure a Terraform backend on AWS S3 with remote state, set up the AWS provider and region variables, and prepare ECS service task definitions for the spring boot app.

Create an ecs task definition for a spring boot app on fargate using a json template with placeholders, including image, env vars, port mappings, and cloudwatch log settings.

Read a task definition JSON as a Terraform template, render it with variables like memory, docker image URL, and spring profile, then create an ECS task definition for AWS Fargate.

Create and configure a security group for the ECS service on Fargate with Terraform, linking the VPC, defining ingress for the Spring Boot app, and allowing outbound internet access.

Create an AWS ALB target group for a Fargate ECS service using Terraform, specifying the container port, IP target type, HTTP health checks at /actuator/health, and health thresholds.

Create an aws alb listener rule in terraform to forward traffic from the load balancer to the ecs target group, using a host header to build a service subdomain.

Create a CloudWatch log group with Terraform using the AWS log group resource, naming it after the service plus a log group suffix; AWS will create log streams automatically.

Review and refine the application infrastructure for a spring boot app on Fargate ECS, including task definition rendering, AWS provider, S3 backend, and execution role fixes, before execution.