The Dev World – Sergio Lema

Why AWS ECS is Your New Best Friend for Microservices

So, you’ve built a shiny new Spring Boot application, and now you’re wondering how to deploy it without losing your sanity. Enter AWS ECS (Elastic Container Service), the managed container orchestration service that lets you run Docker containers without having to babysit a Kubernetes cluster. If you’re deploying microservices, ECS is like that friend who shows up with pizza and beer—simple, reliable, and always there when you need it.

In this guide, we’ll walk through deploying a Spring Boot application to AWS ECS Fargate, the serverless compute engine for containers. No EC2 instances to manage, no nodes to patch—just your application, running happily in the cloud. Let’s get started.

AWS ECS Fargate vs EC2: Why Fargate is the Lazy Developer’s Dream

Before we dive in, let’s address the elephant in the room: Why Fargate over EC2? Well, imagine you’re at a buffet. With EC2, you have to cook your own food, clean the dishes, and maybe even grow the vegetables. With Fargate, you just show up, eat, and leave. No cleanup, no hassle.

Here’s why Fargate is the superior choice for most use cases:

• No Infrastructure Management: Fargate handles the underlying servers for you. No more worrying about EC2 instance types, scaling, or patching.
• Cost-Effective for Microservices: You only pay for the resources your containers use, not for idle EC2 instances.
• Simpler Configuration: Fargate abstracts away the complexity of managing clusters, so you can focus on writing code instead of debugging YAML files.

Sure, EC2 gives you more control, but let’s be honest—most of us don’t need that level of control. We just want our apps to run.

My Spring Boot Application: Hello, World! (Again)

To keep things simple, we’ll build a Spring Boot application with a single endpoint: /hello. Because nothing says “I’m a professional developer” like a “Hello, World!” API.

Here’s the code for your HelloController.java:

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

And of course, you’ll need a Dockerfile to containerize this masterpiece:

FROM openjdk:17-jdk-alpine
COPY target/my-spring-boot-app.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Build the Docker image locally to make sure it works:

docker build -t my-spring-boot-app .
docker run -p 8080:8080 my-spring-boot-app

If you can hit http://localhost:8080/hello and see “Hello, World!”, congratulations—you’re halfway there.

Prepare AWS: Because Nothing Works Without a VPC

Before we can deploy to ECS, we need to set up a few things in AWS. Think of this as the “prep work” before the fun part.

1. Create a VPC: If you don’t already have one, create a VPC with public and private subnets. Because running your app in the default VPC is like living in your parents’ basement—it works, but it’s not ideal.
2. Security Groups: Create a security group that allows inbound traffic on port 8080 (or whatever port your app uses). Because security is important, but so is actually being able to access your app.
3. Elastic Container Registry (ECR): Create an ECR repository to store your Docker image. This is where your app will live before it gets deployed to ECS.

My ECS Fargate Cluster: The Heart of the Operation

Now it’s time to create your ECS Fargate cluster. This is where the magic happens.

1. Go to the ECS console and create a new cluster. Choose the “Networking only” template because, remember, we’re using Fargate—no EC2 instances here.
2. Configure your cluster with a name (e.g., my-spring-boot-cluster) and the VPC you created earlier.
3. Set up a task definition. This is where you define your container configuration, including the Docker image, CPU, memory, and port mappings.

Deploy My Application: Push, Deploy, and Pray

With everything set up, it’s time to deploy your application. Here’s how:

1. Push Your Docker Image to ECR:bashCopyaws ecr get-login-password –region <your-region> | docker login –username AWS –password-stdin <your-account-id>.dkr.ecr.<your-region>.amazonaws.com docker tag my-spring-boot-app:latest <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/my-spring-boot-app:latest docker push <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/my-spring-boot-app:latest
2. Update Your ECS Service:
   Use the AWS CLI to update your ECS service with the new Docker image:bashCopyaws ecs update-service –cluster my-spring-boot-cluster –service my-spring-boot-service –force-new-deployment
3. Test Your Deployment:
   Once the service is up and running, grab the public IP of your Fargate task and hit the /hello endpoint. If you see “Hello, World!”, give yourself a pat on the back—you’ve just deployed a Spring Boot app to AWS ECS Fargate.

Conclusion: Fargate is the Hero We Deserve

AWS ECS Fargate is a fantastic choice for deploying microservices, especially if you want to avoid the complexity of Kubernetes. It’s simple, scalable, and serverless—everything a modern developer could ask for. Sure, Kubernetes is great if you’re running a multinational corporation, but for the rest of us, Fargate is more than enough.

So, the next time someone tells you to use Kubernetes for your tiny side project, just smile and say, “I’ll stick with Fargate, thanks.” Because sometimes, less is more.

Now go forth and deploy! And remember, if something breaks, it’s probably DNS.