- Notifications
You must be signed in to change notification settings - Fork1.4k
Example code for the book Microservice patterns
License
microservices-patterns/ftgo-application
Folders and files
| Name | Name | Last commit message | Last commit date | |
|---|---|---|---|---|
Repository files navigation
This is the example code for my bookMicroservice patterns.
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 16GB Macbook pro.
The application’s services and the infrastructure services, such as MySQL and Apache Kafka, are deployed using Docker containers using either Docker Compose or Kubernetes.
Please create agithub issue and I’ll do my best to help you.
Not surprisingly, this application has a microservice architecture.There are the following services:
ftgo-consumer-service - the
Consumer Serviceftgo-restaurant-service - the
Restaurant Serviceftgo-order-service - the
Order Serviceftgo-kitchen-service - the
Kitchen Serviceftgo-accounting-service - the
Accounting Serviceftgo-order-history-service - a
Order History Service, which is a CQRS viewftgo-api-gateway - the API gateway
Key points:
A service consists of a single Gradle module.For example,
ftgo-order-serviceimplements theOrder ServiceA service is a Spring Boot application
A service has a Swagger UI
http://…/swagger-ui.html. Seeopen-swagger-uis.shA 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 messagingEventuate Tram Saga framework- implements sagasEventuate Client framework- implements event sourcing
This section maps the chapters to the code.
The services have a REST API
The services also communicate using the Apache Kafka message broker via the
Eventuate Tramframework
Theftgo-order-service uses sagas to maintain data consistency:
The services that participate in these sagas define the following command handlers:
Accounting ServiceAccountingServiceCommandHandlerConsumer ServiceConsumerServiceCommandHandlersKitchen ServiceKitchenServiceCommandHandlerOrder ServiceOrderCommandHandlers
All the services' business logic is implemented using Domain-Driven design aggregates.
Accounting ServiceAccountaggregate in theftgo-accounting-service
Consumer ServiceOrder ServiceKitchen ServiceRestaurant Service
The
Accountaggregate in theftgo-accounting-service is implemented using event sourcing
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
ftgo-api-gateway is the API gateway
Java 8+
Docker and Docker Compose
Internet access so that Gradle and Docker can download dependencies and container images
Temporary: Build the Spring Cloud Contracts using this command:
./gradlew buildContractsBuild the services using this command:
./gradlew assembleRun the application using this command:
./gradlew :composeUpNote: the ':'
This can take a while.
Use the services Swagger UIs to invoke the services.
Create consumer -
http://localhost:8081/swagger-ui/index.htmlCreate a restaurant -
http://localhost:8084/swagger-ui/index.htmlCreate an order -
http://localhost:8082/swagger-ui/index.htmlView the order -
http://localhost:8082/swagger-ui/index.htmlView the order history -
http://localhost:8086/swagger-ui/index.html
You can also access the application via theAPI Gateway athttp://localhost:8087.However, currently it doesn’t have a Swagger UI so you will have to usecurl, for example.
Note: if the containers aren’t accessible vialocalhost - e.g. you are using Docker Toolbox, you will have to use${DOCKER_HOST_IP} as described below.
You can find Kubernetes YAML files in the following directories:deployment/kubernetes and*/src/deployment/kubernetes.There are also some helpful shell scripts.
You should not need to set any environment variables.To run the application, you certainly do not.Similarly, to do development (e.g. run tests), you typically do not need to set any environment variables.That’s because Docker containers are generally accessible (e.g. Docker for Windows/Mac) on the host vialocalhost.However, if Docker is running elsewhere (e.g. you are using Docker Toolbox) you will need to setDOCKER_HOST_IP.
The value ofDOCKER_HOST_IP must be meaningful to both Java services/tests running on your desktop/laptop and to Docker containers.Please do NOT set it to the unresolvable hostname of your machine,localhost or127.0.0.1 since the Docker containers will probably not work correctly.
You can verify thatDOCKER_HOST_IP is set correctly by running this command:
docker run -p 8889:8888 -e DOCKER_DIAGNOSTICS_PORT=8889 -e DOCKER_HOST_IP \ --rm eventuateio/eventuateio-docker-networking-diagnostics:0.2.0.RELEASE
If you want to run Java services/tests within your IDE on your desktop/laptop AND the Docker containers are not accessible vialocalhost THEN you will need to setDOCKER_HOST_IP within your IDE.How to do this depends on your operating system and IDE.For example, I find it convenient to launch my IDE from the command line and after setting this environment variable.
About
Example code for the book Microservice patterns
Resources
License
Uh oh!
There was an error while loading.Please reload this page.
Stars
Watchers
Forks
Packages0
Uh oh!
There was an error while loading.Please reload this page.
