FTGO example application

This is the example code for my book Microservice patterns.

Please note

• The code is still work in progress

• It primarily illustrates the technical aspects of the microservice architecture and so the business logic is minimal

• The documentation is sparse/non-existent and you will need to look in the book

• The application consists of many services and so requires a lot of memory. It runs well, for example, on a 16MB Macbook pro.

• The application’s services and the infrastructure services, such as MySQL and Apache Kafka, are deployed using Docker containers.

Got questions

Please post a message to the book’s discussion forum or create a github issue. I’ll do my best to help you.

Application architecture

Not surprisingly, this application has a microservice architecture. There are the following services:

• ftgo-consumer-service - the Consumer Service

• ftgo-restaurant-service - the Restaurant Service

• ftgo-order-service - the Order Service

• ftgo-restaurant-order-service - the Restaurant Order Service

• ftgo-accounting-service - the Accounting Service

• ftgo-order-history-service - a Order History Service, which is a CQRS view

• ftgo-api-gateway - the API gateway

Service design

Key points:

• A service consists of a single Gradle module. For example, ftgo-order-service implements the Order Service

• A service is a Spring Boot application

• A service has a Swagger UI http://…​/swagger-ui.html. See open-swagger-uis.sh

• A service typically consists of the following packages:

  • domain - domain logic including aggregates

  • messaging - messaging adapters

  • web - Spring MVC controllers (HTTP adapters)

  • main - the main application

• The services use the following other frameworks

  • Eventuate Tram framework - implements transactional messaging

  • Eventuate Tram Saga framework - implements sagas

  • Eventuate Client framework - implements event sourcing

Chapter by chapter

This section maps the chapters to the code.

Chapter 3 Inter-process communication in a microservice architecture

• The services have a REST API

• The services also communicate using the Apache Kafka message broker via the Eventuate Tram framework

Chapter 4 Managing transactions with sagas

The ftgo-order-service uses sagas to maintain data consistency:

• CreateOrderSaga

• CancelOrderSaga

• ReviseOrderSaga

The services that participate in these sagas define the following command handlers:

• Accounting Service AccountingServiceCommandHandler

• Consumer Service ConsumerServiceCommandHandlers

• Restaurant Order Service RestaurantOrderServiceCommandHandler

• Order Service OrderCommandHandlers

Chapter 5 Designing business logic in a microservice architecture

All the services' business logic is implemented using Domain-Driven design aggregates.

• Accounting Service

  • Account aggregate in the ftgo-accounting-service

• Consumer Service

  • Consumer

• Order Service

  • Order

  • Restaurant

• Restaurant Order Service

  • Restaurant

  • RestaurantOrder

• Restaurant Service

  • Restaurant

Chapter 6 Developing business logic with event sourcing

• The Account aggregate in the ftgo-accounting-service is implemented using event sourcing

Chapter 7 Implementing queries in a microservice architecture

• ftgo-order-history-service is an example of a CQRS view

• ftgo-api-gateway uses API composition to implement the REST endpoint for retrieving the order history

Chapter 8 External API patterns

• ftgo-api-gateway is the API gateway

Building and running the application

Pre-requisites

• Java 8

• Docker and Docker Compose

• Internet access so that Gradle and Docker can download dependencies and container images

• The ftgo-order-history-service uses AWS DynamoDB and so requires an access key and secret.

Building

Build the services using this command:

./gradlew assemble

Setting environment variables

To run the application you must set the DOCKER_HOST_IP environment variable to the IP address of where the Docker containers are running:

• Docker toolbox/Virtual machine - IP address of the virtual machine

• Docker for Windows/Mac/Linux - IP address of your laptop/desktop

Please do NOT set it to the (unresolvable) hostname of your machine, localhost or 127.0.0.1.

You must also set the AWS environment variables.

Running the application

Run the application using this command:

docker-compose up -d

This can take a while

Using the application

Use the services Swagger UIs to invoke the services.

• Create consumer - http://${DOCKER_HOST_IP?}:8081/swagger-ui.html

• Create a restaurant - http://${DOCKER_HOST_IP?}:8084/swagger-ui.html

• Create an order - http://${DOCKER_HOST_IP?}:8082/swagger-ui.html

• View the order - http://${DOCKER_HOST_IP?}:8082/swagger-ui.html

• View the order history - http://${DOCKER_HOST_IP?}:8086/swagger-ui.html

You can also access the application via the API Gateway at http://${DOCKER_HOST_IP?}:8087. However, currently it doesn’t have a Swagger UI so you will have to use curl, for example.

Stopping the application

Stop the application using this command:

docker-compose down -v