Why this guide exists and why you will thank it later

Deploying Spring Boot microservices to Amazon ECS sounds like a heroic quest until you realize the dragon is just a YAML file and a forgotten environment variable. This guide walks you through building Docker images, pushing them to Amazon ECR, wiring an ECS task definition, and serving traffic with an Application Load Balancer and Fargate or EC2. You will still need coffee and occasional swearing but the end result will be a resilient container deployment you can actually explain to your manager.

Build a small Docker image for each Spring Boot service

Use Maven or Gradle to produce a runnable jar. Prefer a multi stage Docker build to keep the final image tiny and fast to pull. Example Dockerfile structure in plain terms

FROM eclipse-temurin:17-jdk as builder
WORKDIR /app
COPY pom.xml mvnw .
COPY src ./src
RUN mvn -B package -DskipTests

FROM eclipse-temurin:17-jre
COPY --from=builder /app/target/app.jar /app/app.jar
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Local test

docker build -t my-svc .
docker run -p 8080:8080 my-svc

Push the image to Amazon ECR so ECS can find it

Create a repository in ECR and authenticate your Docker client with the AWS CLI. Replace region and account id with your values.

aws ecr create-repository --repository-name my-svc
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com
docker tag my-svc:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-svc:latest
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-svc:latest

Create an ECS task definition with sane defaults

The task definition is the contract between ECS and your container. Include container name, image uri, cpu and memory, port mappings, and environment variables. Use the awslogs driver for CloudWatch integration so you can debug without spelunking into containers.

• cpu and memory based on service needs and expected concurrency
• port mappings to expose the container port used by Spring Boot
• environment variables for non secrets configuration
• logConfiguration using awslogs to send stdout to CloudWatch

Secrets and configuration management

Do not put secrets in plain text in the task definition. Use AWS Systems Manager Parameter Store or AWS Secrets Manager and reference them as environment variables in the task definition. On Fargate you can map secrets directly into container env variables which is much cleaner than stashing creds in code.

Choose Fargate or EC2 and create a service

Fargate removes the need to manage EC2 instances so you can focus on app logic. Use EC2 when you need special host access or want cheaper steady state pricing and are comfortable managing instances. Create an ECS cluster, then a service using the task definition and set desired count for replicas.

• Enable health checks so unhealthy tasks are replaced automatically
• Set deployment options like minimum healthy percent and maximum percent to control rolling updates

Attach an Application Load Balancer and route traffic

Create an ALB and a target group that maps to your container port. Configure health checks on the target group to use your /actuator/health or equivalent endpoint so ECS knows when to remove bad tasks. Ensure security groups and subnets allow inbound traffic and that the ALB can reach your tasks.

CI CD and automated deployments

Automate builds and image pushes with your CI system, for example GitHub Actions or AWS CodeBuild. Typical pipeline steps

1. Run unit tests and build the jar
2. Build and tag Docker image
3. Push image to ECR
4. Update ECS task definition with new image uri and run a deployment

You can automate the ECS update with the AWS CLI or SDK calls. CI CD keeps humans from doing monotonous tasks which improves morale and reduces outages.

Troubleshooting and final tips

If tasks fail to start check CloudWatch logs first. Common issues include wrong environment variables, missing secrets, or mismatched container ports. If the load balancer reports unhealthy targets verify the health endpoint and security groups.

Keep images small, reuse base layers, and set resource limits on the task definition so one runaway process does not take down the whole service. Monitor CPU and memory in CloudWatch and set alarms before users start complaining.

There you go. A pragmatic path to get Spring Boot microservices running on Amazon ECS with Docker and ECR without summoning chaos. Now go deploy something that scales and blame the CI when it breaks.