vany0114/microservices-dotnetcore-docker-sf-k8s

This system is a microservices-based ride-hailing platform that manages the end-to-end lifecycle of trips, including creation, status updates, and location tracking. It coordinates with an external payment service to handle invoicing and transactions, while using an event-driven architecture to synchronize state across services via message brokers. The platform also provides real-time user notifications and maintains reporting views for trip and driver analytics.

22 changes.

This period established the foundational structure of the Duber microservices solution, introducing core domain models for trips, invoices, and users alongside their respective APIs. It implemented the underlying infrastructure, including an event bus with RabbitMQ and Azure Service Bus support, and configured Docker Compose and Service Fabric for container orchestration. The work also integrated external payment services and set up initial deployment scripts for Azure resources.

8 changes.

This period focused on hardening the distributed system by adding comprehensive health checks, idempotency handling for integration events, and robust resilience policies using Polly. It also established the operational foundation for local and cloud-based Kubernetes deployments, enabling reliable service discovery and real-time notifications via SignalR.

A new Windows batch script (create-resources.cmd) has been added to the deploy directory to automate the creation of Azure resources. This script accepts an ARM template name, a resource group name, and an optional location flag to create a new resource group, then deploys the specified ARM template and its parameters to that group using the Azure CLI.

deploy · high confidence

The Duber.Infrastructure.WebHost project now includes a launchSettings.json file configuring IIS Express and direct project profiles for local development on ports 5000/5001. Additionally, a new WebHostExtensions class provides a MigrateDbContext helper that automatically applies Entity Framework Core migrations and runs a provided seeder action when the application starts, ensuring the database schema is up-to-date.

src/Infrastructure/Duber.Infrastructure.WebHost · high confidence

The EventBus infrastructure now includes an idempotency layer to prevent duplicate processing of integration events. This introduces a new \IdempotentIntegrationEvent\ wrapper and a corresponding \IdempotentIntegrationEventHandler\ that checks an \IIdempotencyStoreProvider\ before publishing the underlying event, ensuring that messages with the same ID are only processed once. The system provides DI extensions (\RegisterDefaultIdempotentHandler\ and \RegisterIdempotentHandlers\) to automatically register this default handler alongside any custom integration event handlers found in the application assembly.

src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.Idempotency · high confidence

The infrastructure layer now provides foundational support for Domain-Driven Design by introducing base classes for Entities, Value Objects, and Enumerations, along with interfaces for Repositories and Unit of Work. This includes an Entity base class that manages domain events and an extension method to dispatch these events via MediatR, enabling a consistent pattern for handling domain logic and persistence across the application.

src/Infrastructure/Duber.Infrastructure · high confidence

The Trip API now includes built-in health checks for the application itself, MongoDB, and the configured message broker (Azure Service Bus or RabbitMQ), allowing external systems to monitor service availability. Additionally, idempotency handling for integration events has been added to prevent duplicate processing of messages like TripFinished, ensuring reliable event handling in distributed scenarios.

src/Application/Duber.Trip.API/Extensions · high confidence

The web application now includes a 'Simulate a Trip' feature that allows users to create, accept, start, and update trips via the TripController, while simultaneously maintaining a reporting materialized view. This is achieved through new integration event handlers (for TripCreated, TripUpdated, InvoiceCreated, and InvoicePaid events) that update the ReportingContext database, and a new ReportingRepository with corresponding EF Core migrations to persist trip details, driver/user information, and payment status for display in the new DriverTrips and UserTrips views.

src/Web · high confidence

Adds Kubernetes deployment, service, and HorizontalPodAutoscaler (HPA) configurations for the invoice, trip, notifications, and frontend (website) services on Google Kubernetes Engine. The set includes a default Ingress resource to route traffic to these services, a ConfigMap for environment variables and connection strings, and shell scripts to deploy and clean up these resources. Additionally, optional deployment variants with a Cloud SQL proxy sidecar are provided for the invoice and frontend services to facilitate database connectivity.

deploy/k8s/gke · high confidence

Adds the Service Fabric application package and deployment infrastructure for the DuberMicroservices application on Linux. This includes manifests for the Invoice and Trip stateless services, which run as guest containers (images vany0114/duber.invoice.api:prod and vany0114/duber.trip.api:prod) with hardcoded environment variables for SQL, MongoDB, and Azure Service Bus connections. The change also provides the MSBuild project file, local and cloud publish profiles, and Azure Resource Manager templates to provision the underlying Service Fabric cluster in Azure.

ServiceFabric, deploy/servicefabric · high confidence

The User bounded context now includes its foundational domain model and data access infrastructure. This introduces the User aggregate root with validation for ratings and payment method changes, alongside the PaymentMethod entity. The persistence layer is established using Entity Framework Core, featuring a dedicated UserContext, entity configurations, and an initial database migration that creates the Users and PaymentMethods tables within the 'User' schema. Additionally, a seeding mechanism is provided to populate the database with default payment methods and sample user data on startup.

src/Domain/Driver, src/Domain/User/Duber.Domain.User · high confidence

This change introduces the core Invoice bounded context, including the Invoice entity with business logic for calculating fees and totals based on trip distance, duration, and status. It adds support for credit card payments via a PaymentInfo value object and a PaymentService that integrates with an external payment adapter. The persistence layer is implemented using Dapper for read/write operations and Entity Framework Core for migrations, creating the Invoices and PaymentsInfo database tables.

src/Domain/Invoice · high confidence

This change introduces the foundational infrastructure components for the Duber.Trip.API, including global exception handling that maps domain errors to HTTP 400/500 responses, model validation filters, and persistence implementations for the event store and idempotency store backed by MongoDB.

src/Application/Duber.Trip.API/Infrastructure · high confidence

This change introduces the complete set of Kubernetes resource definitions and PowerShell automation scripts required to deploy the application stack locally. It includes deployments, services, and ingress rules for the frontend, invoice, trip, notifications, and payment services, along with infrastructure components for MongoDB, Redis, RabbitMQ, and SQL Server. The entry also adds a shared ConfigMap for environment variables, an Nginx Ingress controller configuration (customized to port 81), and a ServiceAccount for the Kubernetes Dashboard. Additionally, it provides \deploy-local.ps1\ and \delete-resources.ps1\ scripts to streamline the provisioning and teardown of this local cluster environment.

deploy/k8s/local · high confidence

This change establishes the foundational project structure for the Duber microservices solution, introducing the initial commit with core documentation (README, architecture guides, license) and build scripts. It configures Docker Compose (v3.4) to orchestrate the application services (Invoice API, Trip API, Website) alongside infrastructure dependencies (SQL Server, MongoDB, RabbitMQ) and introduces a new Trip Notifications service. The solution file is updated to reflect the new project hierarchy, including domain, infrastructure, and application layers, while also adding an .env file template for environment variable management.

(repo-wide) · high confidence

Added a new adapter for integrating with an external payment system. This includes the \PaymentServiceAdapter\ which handles HTTP requests to the payment provider's API, an interface \IPaymentServiceAdapter\, a translator for converting the provider's JSON response into internal \PaymentInfo\ models, and helper classes for constructing the API endpoint URI.

src/Domain/Duber.Domain.ACL · high confidence

A new PaymentService has been added to the system, providing an external payment integration capability. The service is built on .NET Core 3.1 and includes a Dockerfile for containerized deployment, along with standard ASP.NET Core startup configuration and logging settings.

ExternalSystem/PaymentService · high confidence

The EventBus infrastructure now includes an in-memory subscription manager that supports both strongly-typed and dynamic event handling. Users can subscribe to specific event types using generic handlers or register dynamic handlers that accept arbitrary event data, allowing for flexible integration patterns. The system manages subscription lifecycles, including adding, removing, and querying handlers for specific events, while maintaining a registry of event types and their associated handlers.

src/Infrastructure/EventBus/Duber.Infrastructure.EventBus · high confidence

Added a new PaymentController exposing an HTTP POST endpoint at /api/payment/performpayment. This endpoint accepts a userId and reference, simulates a payment transaction with a fixed latency, and returns a list containing the payment status, card type, generated card number, user ID, and reference.

ExternalSystem/PaymentService/Controllers · high confidence

The resilience infrastructure now exposes \IPolicyAsyncExecutor\ and \IPolicySyncExecutor\ interfaces along with their implementations, allowing code to execute actions wrapped in Polly policies. For SQL operations, a new builder pattern (\SqlPolicyBuilder\) provides fluent APIs (\ISqlAsyncPolicyBuilder\ and \ISqlSyncPolicyBuilder\) to configure retry, circuit breaker, timeout, and fallback policies specifically for Azure SQL transient errors. Additionally, a \ResilientHttpClient\ wrapper is introduced to attach Polly execution contexts to HTTP requests.

src/Infrastructure/Duber.Infrastructure.Resilience.Abstractions, src/Infrastructure/Duber.Infrastructure.Resilience.Http, src/Infrastructure/Duber.Infrastructure.Resilience.Sql · high confidence

The application now registers the RabbitMQ-based event bus infrastructure via the new \AddRabbitMQ\ extension method. This configures the RabbitMQ connection factory using settings such as \EventBusConnection\, \EventBusUserName\, and \EventBusPassword\, and wires up the persistent connection and event bus implementations. Additionally, a dedicated health check for the RabbitMQ bus is registered, allowing the system to monitor the connectivity status of the message broker.

src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.RabbitMQ/IoC · high confidence

The Trip Notifications service now delivers live updates to clients using ASP.NET Core SignalR. It listens for integration events (TripCreated, TripFinished, TripUpdated, TripCancelled) and pushes corresponding status changes or location updates to connected users. The service supports both RabbitMQ and Azure Service Bus for event consumption, uses Redis for SignalR backplane scaling in cluster deployments, and exposes readiness/liveness health checks.

src/Application/Duber.Trip.Notifications · high confidence

The Service Bus event bus infrastructure now registers its core components through a new \ServiceCollectionExtensions\ class. This adds \IServiceBusPersisterConnection\ and \IEventBus\ (backed by \EventBusServiceBus\) to the dependency injection container, configuring them with connection strings and retry counts from the application configuration. Additionally, it provides an extension method \AddAzureServiceBusTopic\ to register a health check for the Azure Service Bus topic, allowing users to monitor the connectivity of the event bus infrastructure.

src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.ServiceBus/IoC · high confidence

The Trip domain now supports creating and updating trips through new CQRS command handlers. Users can initiate a trip by providing user ID, driver ID, pickup/drop-off locations, vehicle details, and payment method. Once created, trips can be accepted, started, cancelled, finished early, or have their current location updated. The domain enforces business rules such as preventing cancellation before acceptance and ensuring origin and destination differ, while emitting domain events to track status changes and trip metrics like duration and distance.

src/Domain/Trip · high confidence

This change introduces the application layer for the Trip API, establishing the core data models (Trip, Location, PaymentMethod) and command structures (CreateTripCommand, UpdateTripCommand) used to manage trip lifecycles. It implements domain event handlers that translate internal domain events (TripCreated, TripUpdated) into integration events (TripCreatedIntegrationEvent, TripFinishedIntegrationEvent, etc.) published via an event bus, enabling downstream services to react to trip status changes. Additionally, it defines AutoMapper profiles to map between view models, commands, and domain events, ensuring a clean separation of concerns and consistent data transformation across the service.

src/Application/Duber.Trip.API/Application · high confidence

The PaymentService now includes configuration files to support deployment and local development. A new Web Deploy publish profile targets an Azure Web App named 'PaymentServiceExternal' in the 'duber' resource group, configured for the .NET Core 3.1 framework. Additionally, launch settings have been added to enable running the service locally via IIS Express or the Project command, defaulting to the 'api/values' endpoint.

ExternalSystem/PaymentService/Properties · high confidence

The application now uses Azure Service Bus for its event bus infrastructure, replacing the previous implementation. This change adds a new Service Bus-specific module containing the core \EventBusServiceBus\ class, which handles publishing integration events to topics and subscribing to them via subscription clients. It also includes \DefaultServiceBusPersisterConnection\ to manage the connection lifecycle and retry policies using Polly, ensuring reliable message delivery and processing within the Duber infrastructure.

src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.ServiceBus · high confidence

The RabbitMQ infrastructure now implements a robust event bus using a persistent connection layer (\DefaultRabbitMQPersistentConnection\) that handles connection retries via Polly and subscribes to failure events for automatic reconnection. Message publishing ensures durability by marking messages as persistent and setting an expiration time. On the consumer side, the bus now uses manual acknowledgements (\autoAck: false\) instead of automatic ones, allowing the system to explicitly acknowledge or reject messages after processing, which prevents data loss if a consumer crashes mid-processing.

src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.RabbitMQ · high confidence

The Invoice API now automatically handles invoice creation and payment integration in response to external trip events. When a trip finishes or is cancelled, the service listens for the corresponding integration events, creates the invoice record, and triggers a payment via the external payment system if a credit card is used. Additionally, domain events for invoice creation and payment are now published as integration events to update downstream query-side materialized views. The API also exposes standard HTTP endpoints to create invoices and retrieve them by ID or trip ID, while removing the previous placeholder Values controller.

src/Application/Duber.Invoice.API · high confidence

The default scaffolded ValuesController has been removed and replaced with a new TripController that exposes endpoints for creating, retrieving, accepting, starting, canceling, and updating the current location of trips. Additionally, an EventStoreController has been added to allow retrieval of aggregates and their associated events, and a HomeController now redirects root access to the Swagger UI.

src/Application/Duber.Trip.API/Controllers · high confidence

The Duber.Trip.API container image is rebuilt using .NET Core 3.1 base images, replacing the previous .NET Core 2.0 setup. The API pipeline has been upgraded to the ASP.NET Core 3.1 middleware model, replacing the legacy MVC pipeline with \UseRouting\, \UseEndpoints\, and explicit controller mapping. A new Autofac dependency injection container is now used to manage services, and the application now exposes dedicated \/readiness\ and \/liveness\ health check endpoints for container orchestration. Additionally, the default logging level has been raised from Warning to Information, and the application now integrates Application Insights telemetry, FluentValidation, and Swagger UI for API documentation.

src/Application/Duber.Trip.API · high confidence

A new unit test project for the User domain has been introduced, containing a basic test class with an empty test method. This provides the structural foundation for adding future unit tests to the User domain logic.

src/Domain/User/Duber.Domain.User.UnitTest · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 32 (-5.0)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 47 → 46 (-1.1)
• Architecture 65 → 65 (+0.0)
• Maturity 54 → 54 (+0.0)
• Readiness 34 → 38 (+3.2)
• Security 28 → 16 (-12.7)
• Domain Modelling 59 → 63 (+4.8)
• Event-Driven 77 → 77 (+0.0)
• Accessibility 69 → 63 (-6.1)

• BarePragmaDisable (src/Application/Duber.Invoice.API/Extensions/ServiceCollectionExtensions.cs)
• BarePragmaDisable (src/Application/Duber.Invoice.API/Program.cs)
• BarePragmaDisable (src/Application/Duber.Invoice.API/Startup.cs)
• BarePragmaDisable (src/Domain/Duber.Domain.SharedKernel/Model/PaymentInfo.cs)
• Bounded contexts not declared
• Duplicated block (11 lines × 2) (src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.RabbitMQ/EventBusRabbitMQ.cs)
• Duplicated block (11 lines × 3) (src/Web/Duber.WebSite/Program.cs)
• Duplicated block (14 lines × 2) (src/Web/Duber.WebSite/Extensions/ServiceCollectionExtensions.cs)
• Duplicated block (15 lines × 2) (src/Infrastructure/Duber.Infrastructure.Resilience.Sql/Policies/AsyncPolicies.cs)
• Duplicated block (16 lines × 2) (src/Application/Duber.Invoice.API/Extensions/ServiceCollectionExtensions.cs)
• Duplicated block (26 lines × 2) (src/Application/Duber.Invoice.API/Infrastructure/Filters/HttpGlobalExceptionFilter.cs)
• High CVE: MessagePack 1.7.3.7
• High CVE: MessagePack 1.7.3.7
• High CVE: System.Net.Security 4.3.0
• High CVE: System.Net.Security 4.3.0
• High IaC: KSV-0014 (deploy/k8s/gke/invoice/invoice-deployment.yaml)
• High IaC: KSV-0014 (deploy/k8s/gke/website/website-deployment.yaml)
• High IaC: KSV-0014 (deploy/k8s/local/invoice/invoice-deployment.yaml)
• High IaC: KSV-0014 (deploy/k8s/local/notifications/notifications-deployment.yaml)
• High IaC: KSV-0014 (deploy/k8s/local/trip/trip-deployment.yaml)
• …and 32 more

• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 2) (src/Infrastructure/Duber.Infrastructure.Resilience.Sql/Policies/AsyncPolicies.cs)
• Duplicated block (11 lines × 3) (src/Application/Duber.Invoice.API/Program.cs)
• Duplicated block (12 lines × 2) (src/Application/Duber.Invoice.API/Program.cs)
• Duplicated block (12 lines × 2) (src/Infrastructure/Duber.Infrastructure.Resilience.Sql/Internals/SqlAsyncPolicyBuilder.cs)
• Duplicated block (13 lines × 3) (src/Domain/Driver/Duber.Domain.Driver/Persistence/EntityConfigurations/DriverStatusEntityTypeConfiguration.cs)
• Duplicated block (15 lines × 2) (src/Application/Duber.Trip.API/Application/IntegrationEvents/TripUpdatedIntegrationEvent.cs)
• Duplicated block (17 lines × 2) (src/Application/Duber.Trip.API/Application/Model/CreateTripCommand.cs)
• Duplicated block (17 lines × 2) (src/Infrastructure/Duber.Infrastructure.Resilience.Sql/Internals/SqlAsyncPolicyBuilder.cs)
• Duplicated block (18 lines × 2) (src/Infrastructure/Duber.Infrastructure.Resilience.Sql/Policies/AsyncPolicies.cs)
• Duplicated block (19 lines × 2) (src/Application/Duber.Invoice.API/Extensions/ServiceCollectionExtensions.cs)
• Duplicated block (21 lines × 2) (src/Application/Duber.Invoice.API/Application/IntegrationEvents/Hnadlers/TripCancelledIntegrationEventHandler.cs)
• Duplicated block (21 lines × 2) (src/Application/Duber.Invoice.API/Extensions/ServiceCollectionExtensions.cs)
• Duplicated block (22–25 lines × 2) (src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.RabbitMQ/EventBusRabbitMQ.cs)
• Duplicated block (31 lines × 2) (src/Application/Duber.Invoice.API/Infrastructure/Filters/HttpGlobalExceptionFilter.cs)
• Duplicated block (38 lines × 2) (src/Application/Duber.Invoice.API/Startup.cs)
• Duplicated block (6 lines × 2) (src/Infrastructure/EventBus/Duber.Infrastructure.EventBus.RabbitMQ/EventBusRabbitMQ.cs)
• Duplicated block (8 lines × 2) (src/Domain/Driver/Duber.Domain.Driver/Persistence/DriverContextSeed.cs)
• …and 341 more

• Unchanged — 14 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

vany0114/microservices-dotnetcore-docker-sf-k8s was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.