Getting Started .NET Core Microservices RabbitMQ

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.

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 the domain core project for a net core microservice app, organizing bus, commands, and events with mediator-based CQRS and a RabbitMQ bus.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.