GitHub - meysamhadeli/booking-microservices: A practical microservices with the latest technologies and architectures like Vertical Slice Architecture, Event Sourcing, CQRS, DDD, gRpc, MongoDB, RabbitMq, Masstransit, and Aspire in .Net 10. (original) (raw)

🚀 A practical microservices with the latest technologies and architectures like Vertical Slice Architecture, Event Sourcing, CQRS, DDD, gRpc, MongoDB, RabbitMq, Masstransit, and Aspire in .Net 10.

You can find other version of this project here:

Open in GitHub Codespaces

Table of Contents

The Goals of This Project

Technologies - Libraries

Key Features

  1. Independent Services: Each service is a separate project with its own database and deployment pipeline, enabling independent development and deployment.
  2. Decentralized Communication: Services communicate via APIs (REST, gRPC) or message brokers (RabbitMQ, Kafka), ensuring loose coupling and resilience.
  3. Scalability: Services can be scaled independently based on demand, allowing efficient resource utilization.
  4. Fault Tolerance: Failures are isolated, preventing cascading failures and ensuring high availability.
  5. Technology Agnostic: Services can use different technologies, frameworks, or databases, providing flexibility.

When to Use

  1. Large and Complex Projects: Ideal for applications with complex business logic that can be broken into smaller, manageable services.
  2. High Scalability Needs: Suitable for applications requiring independent scaling of components.
  3. Fault Tolerance and High Availability: Perfect for systems where failure isolation and uptime are critical.
  4. Distributed Teams: Enables teams to work independently on different services.
  5. Frequent Updates: Supports continuous deployment and A/B testing for individual services.
  6. Technology Diversity: Allows the use of different technologies for different services.

Challenges

The Domain And Bounded Context - Service Boundary

Structure of Project

In this project, I used vertical slice architecture at the architectural level and feature folder structure to structure my files.

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 ASP.net 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:

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.

Development Setup

Dotnet Tools Packages

For installing our requirement packages with .NET cli tools, we need to install dotnet tool manifest.

And after that we can restore our dotnet tools packages with .NET cli tools from .config folder and dotnet-tools.json file.

Husky

Here we use husky to handel some pre commit rules and we used conventional commits rules and formatting as pre commit rules, here in package.json. of course, we can add more rules for pre commit in future. (find more about husky in the documentation) We need to install husky package for manage pre commits hooks and also I add two packages @commitlint/cli and @commitlint/config-conventional for handling conventional commits rules in package.json. Run the command bellow in the root of project to install all npm dependencies related to husky:

Note: In the root of project we have .husky folder and it has commit-msg file for handling conventional commits rules with provide user friendly message and pre-commit file that we can run our scripts as a pre-commit hooks. that here we call format script from package.json for formatting purpose.

Upgrade Nuget Packages

For upgrading our nuget packages to last version, we use the great package dotnet-outdated. Run the command below in the root of project to upgrade all of packages to last version:

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{HOME}/.aspnet/https/aspnetapp.pfx -p HOME/.aspnet/https/aspnetapp.pfx−pCREDENTIAL_PLACEHOLDER$ dotnet dev-certs https --trust

Aspire

To run the application using the Aspire App Host, execute the following command from the solution root:

Note:The Aspire dashboard will be available at http://localhost:18888

Docker Compose

To run this app in Docker, use the docker-compose.yaml and execute the below command at the root of the application:

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

Kubernetes

To configure TLS in the Kubernetes cluster, we need to install cert-manager based on the docs and run the following commands to apply TLS in our application. Here, we use Let's Encrypt to encrypt our certificate.

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

To apply all necessary deployments, pods, services, ingress, and config maps, please run the following command:

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

Build

To build all microservices, run this command in the root of the project:

Run

To run each microservice, run this command in the root of the Api folder of each microservice where the csproj file is located:

Test

To test all microservices, run this command in the root of the project:

Documentation Apis

Each microservice provides API documentation and navigate to /swagger for Swagger OpenAPI or /scalar/v1 for Scalar OpenAPI to visit list of endpoints.

As part of API testing, I created the booking.rest file which can be run with the REST Client VSCode plugin.

Support

If you like my work, feel free to:

Thanks a bunch for supporting me!

Contribution

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

License

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