Booking Microservices

A microservices, built with .Net, DDD, CQRS, Event Sourcing, Vertical Slice Architecture, Event-Driven Architecture, and the latest technologies.
Alternatives To Booking Microservices
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Architect Awesome57,200
7 months ago62
Awesome Ddd9,877
23 days ago6
A curated list of Domain-Driven Design (DDD), Command Query Responsibility Segregation (CQRS), Event Sourcing, and Event Storming resources
Modular Monolith With Ddd7,880
5 months ago53mitC#
Full Modular Monolith application with Domain-Driven Design approach.
a month ago9mitC#
Full ASP.NET Core 6 application with DDD, CQRS and Event Sourcing concepts
Wild Workouts Go Ddd Example4,047
2 months ago28mitGo
Go DDD example application. Complete project to show how to apply DDD, Clean Architecture, and CQRS by practical refactoring.
Axonframework3,0462245316 hours ago89July 08, 202286apache-2.0Java
Framework for Evolutionary Message-Driven Microservices on the JVM
Php Ddd Example2,614
a month ago66PHP
🐘🎯 Hexagonal Architecture + DDD + CQRS in PHP using Symfony 6
Sample Dotnet Core Cqrs Api2,289
4 months ago9mitC#
Sample .NET Core REST API CQRS implementation with raw SQL and DDD using Clean Architecture.
Ultimate Backend2,215
a day ago61mitTypeScript
Multi tenant SaaS starter kit with cqrs graphql microservice architecture, apollo federation, event source and authentication
Eventflow2,1965232 days ago114March 15, 202220otherC#
Async/await first CQRS+ES and DDD framework for .NET
Alternatives To Booking Microservices
Select To Compare

Alternative Project Comparisons
ci-status build-status

The main idea of creating this project is implementing an infrastructure for up and running distributed system with the latest technology and architecture like Vertical Slice Architecture, Event Sourcing, CQRS, DDD, gRpc, MongoDB, RabbitMq, Masstransit in .Net, and we will not deal mainly with business.

Open in Gitpod

Table of Contents

The Goals of This Project

  • ❇️ Using Vertical Slice Architecture for architecture level.
  • ❇️ Using Domain Driven Design (DDD) to implement all business processes in microservices.
  • ❇️ Using Rabbitmq on top of Masstransit for Event Driven Architecture between our microservices.
  • ❇️ Using gRPC for internal communication between our microservices.
  • ❇️ Using CQRS implementation with MediatR library.
  • ❇️ Using Postgres for write side of some microservices.
  • ❇️ Using MongoDB for read side of some microservices.
  • ❇️ Using Event Store for write side of Booking-Microservice to store all historical state of aggregate.
  • ❇️ Using Inbox Pattern for ensuring message idempotency for receiver and Exactly once Delivery.
  • ❇️ Using Outbox Pattern for ensuring no message is lost and there is at Least One Delivery.
  • ❇️ Using Unit Testing, Integration Testing, End To End Testing for testing level.
  • ❇️ Using Fluent Validation and a Validation Pipeline Behaviour on top of MediatR.
  • ❇️ Using Minimal API for all endpoints.
  • ❇️ Using Health Check for reporting the health of app infrastructure components.
  • ❇️ Using Docker-Compose and Kubernetes for our deployment mechanism.
  • ❇️ Using OpenTelemetry for distributed tracing.
  • ❇️ Using IdentityServer for authentication and authorization base on OpenID-Connect and OAuth2.
  • ❇️ Using Yarp as a microservices gateway.


This project is a work in progress, new features will be added over time.

I will try to register future goals and additions in the Issues section of this repository.

High-level plan is represented in the table

Feature Status
API Gateway Completed
Identity Service Completed
Flight Service Completed
Passenger Service Completed
Booking Service Completed
Building Blocks Completed

Technologies - Libraries

  • .NET 7 - .NET Framework and .NET Core, including ASP.NET and ASP.NET Core
  • MVC Versioning API - Set of libraries which add service API versioning to ASP.NET Web API, OData with ASP.NET Web API, and ASP.NET Core
  • EF Core - Modern object-database mapper for .NET. It supports LINQ queries, change tracking, updates, and schema migrations
  • Masstransit - Distributed Application Framework for .NET.
  • MediatR - Simple, unambitious mediator implementation in .NET.
  • FluentValidation - Popular .NET validation library for building strongly-typed validation rules
  • Swagger & Swagger UI - Swagger tools for documenting API's built on ASP.NET Core
  • Serilog - Simple .NET logging with fully-structured events
  • Polly - Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner
  • Scrutor - Assembly scanning and decoration extensions for Microsoft.Extensions.DependencyInjection
  • Opentelemetry-dotnet - The OpenTelemetry .NET Client
  • DuendeSoftware IdentityServer - The most flexible and standards-compliant OpenID Connect and OAuth 2.x framework for ASP.NET Core
  • EasyCaching - Open source caching library that contains basic usages and some advanced usages of caching which can help us to handle caching more easier.
  • Mapster - Convention-based object-object mapper in .NET.
  • Hellang.Middleware.ProblemDetails - A middleware for handling exception in .Net Core
  • NewId - NewId can be used as an embedded unique ID generator that produces 128 bit (16 bytes) sequential IDs
  • Yarp - Reverse proxy toolkit for building fast proxy servers in .NET
  • Tye - Developer tool that makes developing, testing, and deploying microservices and distributed applications easier
  • gRPC-dotnet - gRPC functionality for .NET.
  • EventStore - The open-source, functional database with Complex Event Processing.
  • MongoDB.Driver - .NET Driver for MongoDB.
  • - A free, open source, community-focused unit testing tool for the .NET Framework.
  • Respawn - Respawn is a small utility to help in resetting test databases to a clean state.
  • Testcontainers - Testcontainers for .NET is a library to support tests with throwaway instances of Docker containers.
  • K6 - Modern load testing for developers and testers in the DevOps era.

The Domain And Bounded Context - Service Boundary

  • Identity Service: The Identity Service is a bounded context for the authentication and authorization of users using Identity Server. This service is responsible for creating new users and their corresponding roles and permissions using .Net Core Identity and Jwt authentication and authorization.

  • Flight Service: The Flight Service is a bounded context CRUD service to handle flight related operations.

  • Passenger Service: The Passenger Service is a bounded context for managing passenger information, tracking activities and subscribing to get notification for out of stock products.

  • Booking Service: The Booking Service is a bounded context for managing all operation related to booking ticket.

Structure of Project

In this project I used a mix of clean architecture, vertical slice architecture and I used feature folder structure to structure my files.

I used yarp reverse proxy to route synchronous and asynchronous requests to the corresponding microservice. Each microservice has its dependencies such as databases, files etc. Each microservice is decoupled from other microservices and developed and deployed separately. Microservices talk to each other with Rest or gRPC for synchronous calls and use RabbitMq or Kafka for asynchronous calls.

We have a separate microservice (IdentityServer) for authentication and authorization of each request. Once signed-in users are issued a JWT token. This token is used by other microservices to validate the user, read claims and allow access to authorized/role specific endpoints.

I used RabbitMQ as my MessageBroker for async communication between microservices using the eventual consistency mechanism. Each microservice uses MassTransit to interface with RabbitMQ providing, messaging, availability, reliability, etc.

Microservices are event based which means they can publish and/or subscribe to any events occurring in the setup. By using this approach for communicating between services, each microservice does not need to know about the other services or handle errors occurred in other microservices.

After saving data in write side, I save a Internal Command record in my Persist Messages storage (like something we do in outbox pattern) and after committing transaction in write side, trigger our command handler in read side and this handler could save their read models in our MongoDB database.

I treat each request as a distinct use case or slice, encapsulating and grouping all concerns from front-end to back. When adding or changing a feature in an application in n-tire architecture, we are typically touching many "layers" in an application. We are changing the user interface, adding fields to models, modifying validation, and so on. Instead of coupling across a layer, we couple vertically along a slice. We minimize coupling between slices, and maximize coupling in a slice.

With this approach, each of our vertical slices can decide for itself how to best fulfill the request. New features only add code, we're not changing shared code and worrying about side effects.

Instead of grouping related action methods in one controller, as found in traditional controllers, I used the REPR pattern. Each action gets its own small endpoint, consisting of a route, the action, and an IMediator instance (see MediatR). The request is passed to the IMediator instance, routed through a Mediatr pipeline where custom middleware can log, validate and intercept requests. The request is then handled by a request specific IRequestHandler which performs business logic before returning the result.

The use of the mediator pattern in my controllers creates clean and thin controllers. By separating action logic into individual handlers we support the Single Responsibility Principle and Don't Repeat Yourself principles, this is because traditional controllers tend to become bloated with large action methods and several injected Services only being used by a few methods.

I used CQRS to decompose my features into small parts that makes our application:

  • Maximize performance, scalability and simplicity.
  • Easy to maintain and add features to. Changes only affect one command or query, avoiding breaking changes or creating side effects.
  • It gives us better separation of concerns and cross-cutting concern (with help of mediatr behavior pipelines), instead of bloated service classes doing many things.

Using the CQRS pattern, we cut each business functionality into vertical slices, for each of these slices we group classes (see technical folders structure) specific to that feature together (command, handlers, infrastructure, repository, controllers, etc). In our CQRS pattern each command/query handler is a separate slice. This is where you can reduce coupling between layers. Each handler can be a separated code unit, even copy/pasted. Thanks to that, we can tune down the specific method to not follow general conventions (e.g. use custom SQL query or even different storage). In a traditional layered architecture, when we change the core generic mechanism in one layer, it can impact all methods.

How to Run


Config Certificate

Run the following commands to Config SSL in your system

Windows using Linux containers

dotnet dev-certs https -ep %USERPROFILE%\.aspnet\https\aspnetapp.pfx -p password
dotnet dev-certs https --trust

Note: for running this command in powershell use $env:USERPROFILE instead of %USERPROFILE%

macOS or Linux

dotnet dev-certs https -ep ${HOME}/.aspnet/https/aspnetapp.pfx -p $CREDENTIAL_PLACEHOLDER$
dotnet dev-certs https --trust

Docker Compose

Run this app in docker using the docker-compose.yaml file with the below command at the root of the application:

docker-compose -f ./deployments/docker-compose/docker-compose.yaml up -d


For Configure TLS in kubernetes cluster we need install cert-manager base on docs and run the following commands for apply TLS in our application. Here we use LetsEncrypt for encryption our certificate.

kubectl apply -f ./deployments/kubernetes/booking-cert-manager.yml

Run the following command to apply all deployments, pods, services, ingress and configmaps that we need

kubectl apply -f ./deployments/kubernetes/booking-microservices.yml

Documentation Apis

Each microservice uses swagger open api, navigate to /swagger for a list of every endpoint. For testing apis I used the REST Client plugin for VS Code running this file


If you like my work, feel free to:

  • this repository. And we will be happy together :)

Thanks a bunch for supporting me!


Thanks to all contributors, you're awesome and this wouldn't be possible without you! The goal is to build a categorized, community-driven collection of very well-known resources.

Please follow this contribution guideline to submit a pull request or create the issue.

Project References & Credits


This project is made available under the MIT license. See LICENSE for details.

Popular Cqrs Projects
Popular Domain Driven Design Projects
Popular Software Architecture Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
C Sharp
Asp Net Core
Event Sourcing
Event Driven