Code Driven Architect

August 15, 2025

Building and Deploying Spring Boot Microservices on AWS – Step-by-Step

Written by: A Java Architect with 25 years of hands-on experience, simplifying cloud for juniors.

If you're a Java developer starting your cloud journey, you're in the right place. In this guide, I'll walk you through the entire process of building and deploying a Spring Boot microservice to AWS. We'll start from scratch — no assumptions about DevOps or AWS mastery — and by the end, you'll have your first cloud-deployed service live and accessible.

What is a Microservice?
Why Spring Boot?
Why AWS for Deployment?
Step-by-Step Guide
Adding Health Checks & Logs
What's Next?

What is a Microservice?

Imagine an e-commerce site like Amazon. Instead of one huge application, it’s split into smaller parts:

Payment Service
Order Service
Product Service

Each of these is a microservice — independently developed, deployed, and scaled.

Why Spring Boot?

Spring Boot is popular for good reasons:

📦 Fast development with pre-built starter modules
🧪 Easy testing with JUnit and Mockito
☁️ Ideal for Docker and cloud deployment
🔒 Ready for security, monitoring, and REST API development

And most importantly, it has a huge community. When you're stuck, Google has your back.

Why AWS for Deployment?

I’ve worked with many cloud providers, but AWS has a slight edge for its simplicity, maturity, and wide toolset. Here's what we’ll use:

ECR – Store Docker images
ECS Fargate – Run containers without managing servers
CloudWatch – View logs and metrics

We'll skip the fancy stuff like Kubernetes for now. Keep it simple and deploy with confidence.

Step-by-Step Guide

Step 1 – Create Your Spring Boot Microservice

Use start.spring.io and add these dependencies:

Spring Web
Lombok
Spring Boot DevTools

@SpringBootApplication
public class ProductServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
    }
}

Sample Controller:

@RestController
@RequestMapping("/products")
public class ProductController {
    @GetMapping
    public List<String> getProducts() {
        return List.of("iPhone", "MacBook", "AirPods");
    }
}

Test locally: mvn spring-boot:run → Visit http://localhost:8080/products

Step 2 – Build Docker Image

Create a file named Dockerfile in your project root:

FROM openjdk:17-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Now build your Docker image:

mvn clean package
docker build -t product-service .

Step 3 – Push Image to Amazon ECR

1. Create ECR Repo:

aws ecr create-repository --repository-name product-service

2. Authenticate Docker:

aws ecr get-login-password | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.<region>.amazonaws.com

3. Tag and Push:

docker tag product-service <account-id>.dkr.ecr.<region>.amazonaws.com/product-service
docker push <account-id>.dkr.ecr.<region>.amazonaws.com/product-service

Step 4 – Deploy to AWS ECS Fargate

Create an ECS Cluster (Fargate type)
Create a Task Definition
Use your ECR image and specify CPU/Memory (e.g., 256 CPU, 512MB RAM)
Expose port 8080
Create a Service → Attach an Application Load Balancer

You can now visit your ALB URL: http://your-load-balancer/products

---

Bonus – Add Health Checks & Logs

Enable Spring Boot Actuator

management.endpoints.web.exposure.include=health

Health check URL becomes:

http://your-load-balancer/actuator/health

Enable ECS Logging to CloudWatch

In task definition, enable logs
Log driver: awslogs
Group: /ecs/product-service

---

What’s Next?

By now, you’ve done something amazing:

Built your first microservice
Packaged it into a Docker image
Deployed it to AWS using ECS
Enabled health checks and logs

Here’s where you can level up next:

Skill	Next Step
API Security	Learn Spring Security & JWT
CI/CD	Explore GitHub Actions or AWS CodePipeline
Database Integration	Connect with AWS RDS (MySQL/PostgreSQL)
Messaging	Try AWS SQS or Kafka (MSK)
Monitoring	Use CloudWatch Alarms and X-Ray

---

Final Thoughts

As someone who's designed systems used by millions, here's my advice to juniors:

Don’t try to master everything at once
Focus on building and shipping your first working service
Understand the basics deeply before chasing buzzwords

Once you have a microservice running in the cloud — that’s a milestone. Pat yourself on the back and keep going!

-- Ganesh
Java & AWS Architect | Mentor | Blogger

Search This Blog