AWS Builder Center

Builder Center

Containerizing Next.js & Spring Boot with Amazon ECS and AWS Fargate

A practical guide to modernizing your full-stack application by wrapping your Next.js frontend and Java Spring Boot backend in Docker containers, and deploying them serverlessly using Amazon ECR and ECS with AWS Fargate.

Introduction
AWS Amplify and Elastic Beanstalk are fantastic for getting a full-stack Next.js and Spring Boot application off the ground quickly. But what happens when your application grows into microservices, or you need absolute consistency between your local development environment and production?
The answer is containerization. In this guide, we will look at how to package our Next.js frontend and Spring Boot API into Docker containers and deploy them without managing a single underlying server, using Amazon Elastic Container Service (ECS) and the AWS Fargate serverless compute engine.
Step 1: Dockerizing Your Stack
Before moving to ECS, both parts of our application need a Dockerfile.
  • For Spring Boot (Backend):
    Create a Dockerfile that uses an OpenJDK base image. It will copy your compiled .jar file into the image and expose port 8080.```dockerfile
    FROM eclipse-temurin:17-jdk-alpine
    COPY target/myapp.jar app.jar
    EXPOSE 8080
    ENTRYPOINT ["java","-jar","/app.jar"]
  • For Next.js (Frontend):
    Use a Node.js base image. The multi-stage build process will install dependencies, build the .next production folder, and start the Next.js server on port 3000.
Step 2: Pushing to Amazon ECR
AWS needs a secure place to store your new container images. This is where Amazon Elastic Container Registry (ECR) comes in.
  1. In the AWS Console, create two private ECR repositories: one for frontend-nextjs and one for backend-springboot.
  2. Authenticate your local Docker client to your AWS account using the AWS CLI.
  3. Build your images (docker build -t my-app .) and tag them with your ECR repository URI.
  4. Push both images to AWS (docker push <aws_account_id>.dkr.ecr.<region>.amazonaws.com/myapp:latest).
Step 3: Serverless Deployment with ECS and Fargate
Now for the magic. We will run these containers without provisioning EC2 instances.
  1. Create an ECS Cluster: Navigate to Amazon ECS and create a new cluster. Choose the AWS Fargate (serverless) infrastructure option.
  2. Create Task Definitions: A Task Definition is a blueprint for your application. You will create two tasks (one for the frontend, one for the backend). Point each task to its respective Image URI in ECR, allocate serverless CPU/Memory (e.g., 1vCPU, 2GB RAM), and map your ports (3000 and 8080).
  3. Launch ECS Services: A Service ensures your tasks stay running. Create a Service for your backend task and attach an Application Load Balancer (ALB). The ALB will route traffic from the internet securely to your Fargate containers. Repeat the process for your frontend.
  4. Connect Them: Just like with Beanstalk, ensure your Next.js container's environment variables point to the new Load Balancer URL of your Spring Boot backend so they can communicate.
Conclusion
By migrating from Elastic Beanstalk to Amazon ECS with Fargate, you achieve true environment parity (thanks to Docker) and infinite scaling capacity without the headache of patching or managing EC2 instances. AWS Fargate provisions exactly the compute resources your containers need to run, and nothing more.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article