Deploying a Microservice Application to an AWS ECS Cluster with Terraform, Consul, and Goreman


In this comprehensive guide, we will walk through the process of deploying a microservice application to an Amazon Elastic Container Service (ECS) cluster using a combination of Terraform, Consul, and Goreman. ECS is a scalable and reliable container orchestration service provided by AWS, Terraform is an Infrastructure as Code (IaC) tool, Consul is a service discovery and configuration management tool, and Goreman helps run multiple services in containers. Together, these tools enable us to provision the necessary AWS resources, manage service discovery, and deploy multiple services within containers in a streamlined manner.

By following the steps outlined in this blog post, you will be able to leverage Terraform to automate the creation of essential AWS resources such as a Virtual Private Cloud (VPC), Elastic Container Registry (ECR), ECS cluster, ECS task definition, and ECS service. Additionally, we will utilize Consul for service discovery and Goreman for running multiple services in containers. Let’s dive in!

Microservice architecture:

Microservice architecture is a popular approach for designing and building web and API applications. It involves breaking down a large monolithic application into smaller, loosely coupled services that can be developed, deployed, and scaled independently. Each microservice focuses on a specific business capability and communicates with other microservices through well-defined APIs. This architecture promotes flexibility, scalability, and maintainability, as different services can be developed using different technologies and can be scaled individually based on demand. Additionally, microservices enable teams to work autonomously, allowing for faster development cycles and easier deployment of updates. By adopting a microservice architecture, organizations can build robust and resilient applications that can easily adapt to changing business requirements and handle high traffic loads effectively.

Why Amazon Elastic Container Service (ECS)?

Amazon Elastic Container Service (ECS) offers several advantages when it comes to deploying microservices in a cloud environment. First and foremost, ECS provides a highly scalable and reliable platform for running containers. It allows you to easily deploy and manage containerized microservices, automatically scaling them based on demand. ECS handles all the underlying infrastructure management, such as cluster provisioning, container orchestration, and load balancing, allowing you to focus on developing and deploying your microservices.

Another advantage of ECS is its tight integration with other AWS services. ECS seamlessly integrates with Elastic Load Balancing, Amazon VPC, AWS Identity and Access Management (IAM), and other services, providing a comprehensive solution for building and deploying microservices. This integration allows you to leverage the full power of the AWS ecosystem, enabling features like automatic scaling, centralized logging, security management, and easy integration with other AWS services.

ECS also offers built-in support for service discovery and load balancing. It integrates with Amazon Route 53 and AWS CloudMap to provide dynamic service discovery, allowing your microservices to easily find and communicate with each other. ECS also supports various load balancing options, such as Application Load Balancers and Network Load Balancers, ensuring that traffic is distributed efficiently across your microservices.

Additionally, ECS provides seamless integration with Amazon Elastic Container Registry (ECR), which allows you to store, manage, and deploy container images. ECR provides a secure and scalable repository for your container images, making it easy to version and deploy your microservices.

Furthermore, ECS offers flexibility in terms of deployment options. It supports both Fargate and EC2 launch types, giving you the choice between serverless container deployments or running containers on EC2 instances. This flexibility allows you to select the most suitable deployment option based on your application requirements and cost considerations.

Overall, AWS ECS provides a robust and feature-rich platform for deploying microservices. It simplifies the management of containerized applications, offers tight integration with other AWS services, and provides scalability, reliability, and flexibility, making it an advantageous choice for building and running microservice architectures in the cloud.


Before we begin, ensure that you have the following prerequisites in place:

  • An AWS account with appropriate permissions to create ECS resources.

  • Terraform is installed on your local machine.

  • Basic familiarity with Docker, microservice architecture concepts, and the Consul and Goreman tools.

Step 1: Provisioning Infrastructure with Terraform:

We will start by defining and provisioning our infrastructure using Terraform. This will involve creating a VPC, ECR repository, ECS cluster, ECS task definition, and ECS service. We will also configure the necessary networking components to ensure seamless communication between the containers.

You can find a sample Terraform infrastructure provisioning code for AWS ECS cluster in this GitHub repository.

Step 2: Configuring Service Discovery with Consul:

To enable service discovery within our microservices architecture, we will deploy Consul within our ECS cluster. Consul provides a decentralized system for service discovery, enabling services to register themselves and discover other services dynamically. We will configure Consul agents within the ECS cluster to facilitate service registration and discovery.

A module for deploying Consul in ECS can be used for this purpose.

The Consul with Dev Server on Fargate example installation deploys a sample application in ECS using the Fargate launch type.

You can find a sample Terraform code to use the above mentioned Consul module.

Step 3: Defining and Running Multiple Services with Goreman:

In a microservices architecture, it is common to have multiple services running simultaneously. Goreman allows us to define and manage multiple services within containers using a Procfile-like configuration. We will create a Goreman configuration file and specify the services we want to run, including our application service and Consul agent. Goreman will handle the process management and ensure all services are running correctly.

You can find an example of writing a Dockerfile, structuring project files, and writing a Procfile for Goreman in this GitHub repository.

Here’s another example for running multiple services using Goreman.

Step 4: Building and Pushing Docker Images:

Before deploying our microservices to the ECS cluster, we need to build Docker images for each service and push them to the ECR repository. We will outline the steps to build the Docker images and push them using the AWS Command Line Interface (CLI). Each service’s Dockerfile should be appropriately configured to include all dependencies and configurations.

You can find an example GitHub action workflow for building Docker images in this GitHub repository.

Step 5: Deploying Microservices to the ECS Cluster:

With our infrastructure provisioned, Consul running for service discovery, and Docker images built and pushed, we can now deploy our microservices to the ECS cluster. We will utilize the ECS service definition and specify the desired number of tasks for each service. ECS will handle the deployment, scaling, and monitoring of our containers.

The ECS task and service definition can be found in this GitHub repository.


In this blog post, we have explored how to deploy a microservice application to an ECS cluster using Terraform for infrastructure provisioning, Consul for service discovery, and Goreman for running multiple services in containers. This powerful combination of tools enables efficient and streamlined management of AWS resources, service discovery, and the deployment of microservices within containers. By following the outlined steps, you can leverage these tools to build and deploy scalable and resilient microservice architectures on AWS. Happy deploying!

Also published on Medium