Getting Started .NET Core Microservices RabbitMQ

Install RabbitMQ on Windows with the official installer after Erlang, the prerequisite, and explore the admin UI for throughput, messages, queues, exchanges in the message broker.

Enable the RabbitMQ management plugin to access the admin dashboard on localhost:15672, log in as guest, and monitor connections, channels, exchanges, queues, and export broker definitions.

Learn to manage rabbitmq with command line tools: stop and start the app, reset to clear queues and exchanges, and add a test administrator user with full permissions.

Use rabbitmq as a broker to publish messages to queues and have a consumer retrieve them; build a simple publisher and consumer to power microservices.

Learn to set up a dotnet core console app and a basic producer using the rabbitmq client, declare a queue, and publish messages to localhost in a producer-consumer setup.

Create a rabbitmq connection factory, open a connection and channel, declare a basic test queue, encode a message as utf-8, and publish it with the queue name as routing key.

Learn how to run and debug a basic dotnet core RabbitMQ producer, inspect the queue and messages, and understand push pop consumption while preparing a consumer.

Set up a consumer console app, install the RabbitMQ client NuGet package (version 5.1.0), rename the main method to receiver, and wire the consumer to receive the published message.

Create a RabbitMQ consumer using a connection factory and channel, declare the basic test queue, and handle received messages via an eventing consumer with auto-acknowledge, printing and exiting on command.

Send multiple messages to the RabbitMQ basic test queue, then start the consumer to receive and process them, noting purge should be used cautiously in production.

Set up a net core microservices solution with RabbitMQ, enabling publish and consume of messages across services with queues, and a custom event bus integrated with RabbitMQ using mediator commands.

Create a git-backed solution named micro rabbit, organize folders for domain, infra bus, infra ioc, and presentation, and commit and push to master for version control with rabbitmq.

Set up the domain core project for a net core microservice app, organizing bus, commands, and events with mediator-based CQRS and a RabbitMQ bus.

Create a generic i event bus interface with send command, publish event, and subscribe methods, plus event handler interfaces to support RabbitMQ and mediator library usage.

Define an abstract command base for the event bus with a timestamp set at construction, using a protected setter. Derived commands inherit this and send messages across microservices.

Create domain event objects and a base abstract message with a message type, wired to the mediator, and define a timestamped abstract event for an IEventBus with RabbitMQ.

Implement a sealed RabbitMQ bus in the infrastructure project that implements the IEventBus, uses mediator to send commands, and sets up publish and subscribe.

Set up a RabbitMQ bus constructor that uses dependency injection to wire the mediator, initialize a handlers dictionary and an event types list, and enable generic event handling.

Publish a generic event to rabbitmq by creating a localhost connection, declaring a queue named after the event, serializing the event with JsonConvert, and publishing utf-8 encoded bytes.

Implement the subscribe method to register event types and handlers via a dictionary, using generics and reflection, validate duplicates, and begin basic RabbitMQ consumption.

Set up an asynchronous RabbitMQ consume flow by creating a connection, declaring a queue named after the event type, and wiring an async consumer to process messages on receipt.

Implement an asynchronous consumer receiver delegate that reads the routing key and message body from delivery args, then processes events by event name in a background handler across microservices.

Implement a dynamic process event system in the Rabbitmq bus by using reflection activators to create handler instances, deserialize messages to event types, and invoke the handle method.

Create the infra IOC project and add microsoft.extensions.dependencyinjection to enable dependency injection for interfaces and implementations. Build confirms success and prepares the next step: implementing the dependency container.

Create a dependency container to bind interfaces to concrete types and register the RabbitMQ event bus with add transient, enabling injection across MVC, Windows service, and console apps.

Commit the infrastructure IOC container project as the initial commit, then sync and push; future videos will build domain objects and microservices.

Build microservices for a banking app by creating isolated services: banking, transfer, report, and notification, each with its own data context, publishing and consuming transfer events via RabbitMQ.

Create a banking microservice folder structure following clean architecture: banking solution folder with API, domain entities, application, and data folders, plus separate projects for each layer to isolate domain entities.

Create the banking microservice by scaffolding an api project named micro rabbit banking api, plus data, domain, and banking libraries; commit, rebuild, and ensure packages restore successfully.

Structure the banking domain microservice by adding models, interfaces, commands, and events folders, with corresponding command and event handlers, and plan for transfer-related event handling and services.

Define a simple account model as a public class account with int account id, string account type, and decimal balance to support backend repository operations in a rabbitmq-based microservice.

Define a public interface IAccountRepository as the bridge between the account entity and a backend SQL Server database, with GetAccounts returning IEnumerable<Account> in the banking domain.

Install entity framework core packages and tools, implement banking db context with an accounts dbset and repository interface, then rebuild to confirm success.

Implement the account repository class that implements the IAccountRepository interface, inject the banking db context via the constructor, and return all accounts from the context.

Define banking application layer by creating account service interfaces and a concrete implementation, apply dependency injection to an account repository, and implement get accounts to return accounts via the repository.

Update the IoC container by registering the banking microservice's account service and repository with transient lifetimes, wire the banking application and data layers, and prepare for commands and events.

Configure the banking api by adding the banking db connection string in appsettings, running the initial migration, and updating startup with ioc, swagger, and mediator to prepare the microservice.

Register services in the IoC container, configure the banking db context with SQL Server using the banking db connection string, and run the initial migration to create the accounts table.

Add Swagger and MediatR packages to the banking API, configure services for Swagger and MediatR, and set the startup to expose Swagger UI on ports 5000 and 5001.

Rename the default banking values controller to banking controller, implement get all accounts at API/banking, inject an account service via dependency injection, and publish transfers to RabbitMQ for other services.

Seed data into the banking microservice, start the api on port 5001, and verify get accounts via swagger by stepping through the controller, service, and repository.

Learn how to finalize a banking microservice by setting up commands and events on the rabbitmq bus, then commit, sync, and push changes to a safe GitHub repository.

Expose a post endpoint in the banking microservice to initiate transfers with an account transfer model, and publish transfer events to the RabbitMQ event bus.

Define and implement the account transfer method in the account service, wiring a transfer command via mediator to the event bus and publishing the account transfer event to RabbitMQ.

Define a base transfer command with from, to, and amount, using protected set. Implement a create transfer command that initializes these values via a constructor.

implement a transfer command handler with mediator, publish a transfer event to rabbitmq, and connect a banking mvc app to the banking microservice for transfers.

Define a create transfer command and inject an event bus via dependency injection, then send the command through the bus for handlers to process and publish to RabbitMQ.

Create a transfer created event that carries from, to, and amount, extends the domain core event, and publish it to RabbitMQ using the event bus from the transfer command handler.

Debug the banking microservice to publish transfer events to rabbitmq and configure the IoC with domain banking commands and their transfer command handler.

Publish a transfer created event to RabbitMQ from the banking microservice, test by posting a transfer, and observe the message queue for downstream consumers.

Commit changes to the banking microservice, publish and send command, then sync and push updates while reinforcing architecture with RabbitMQ, mediator, and event bus.

Create and organize the transfer microservice with api, domain, data, and application projects, subscribe to transfer created events on the event bus, and commit the initial repository.

Create the initial folder structure for the transfer microservice, including domain, data, and application folders with commands, events, interfaces, models, and repositories; then build and commit.

Copy NuGet packages from the banking microservice to the transfer microservice, installing mediator extensions and Swashbuckle, plus Entity Framework Core SQL Server tools to align dependencies.

Duplicate the banking context to create a transfer DbContext and domain models, define a transfer log with from, to, and amount, and wire the transfer data context to RabbitMQ.

Clean up the transfer microservice before adding events, and configure the transfer db context. Create and apply an initial migration to generate transfer logs in SQL Server.

Set up the transfer microservice by aligning interfaces, domain models, and repositories, enabling transfer log retrieval and event bus integration for RabbitMQ message consumption.

Update the dependency container to wire the new transfer microservice by mapping interfaces to implementations, register transfer service, repository, and data context as transient, and prepare for RabbitMQ message handling.

Seed data and launch the transfer API with Swagger to view transfers. Subscribe to transfer events via the event bus, wire the transfer controller and service, and expose transfer logs.

Copy the transfer created event from the banking domain, implement a transfer event handler in the transfer microservice, register it, and wire the event bus for future commands or notifications.

Update the dependency container by adding domain events, including the transfer created event, and bind it to the transfer event handler using services.add transient and register the references.

Configure the event bus in the transfer api startup to subscribe to the transfer created event, retrieving IEventBus from app services and wiring the handler.

Diagnose end-to-end microservice workflows using RabbitMQ: publish commands, subscribe consumers, and process transfer created events across banking and transfer services.