Event Driven Microservices Architecture with .NET and Docker

Package all relevant modules into a single execution unit to form a deployable monolithic application with independent layers for the user interface, application logic, and data access.

Describe a microservices architecture as a collection of autonomous, small services each implementing an individual business functionality within a bounded context that defines the domain model.

Learn how the saga pattern manages distributed transactions in microservices with orchestrated and choreographed approaches, using compensation for eventual consistency.

Design an event-driven microservices diagram, coordinating transaction, balance, control, and notification services via an event bus, dead-event storage, and a secure vault, with an api gateway and per-service databases.

Create an infrastructure diagram in Draw.io for an event-driven Azure microservices architecture, detailing API gateway, Azure Service Bus, SQL, Cosmos DB, storage, Azure Function, and application insights.

Learn how microservices exchange information through an event-based architecture using a topic and subscriptions, tracing from the api gateway to transaction, balance, transfer, and notification services.

Master a clear resource name nomenclature for azure resources by combining resource type, product, region, and numbering to organize vnet, vm, and public ip resources across environments.

Explore Terraform structure for Azure deployments, defining providers and resources, and using init, plan, apply, destroy, and validate workflows with a service principal for RBAC.

set up a resource group in Azure using Terraform, initialize and plan changes, apply to create the group in West US, and verify in the Azure portal.

Implement a Terraform-driven Azure App Service and App Service Plan to host an API gateway and multiple microservices using Linux containers with a Docker nginx image.

Implement SQL data infrastructure for an event-driven microservices app by provisioning Azure SQL servers and databases with Terraform, configuring region, credentials, and basic plans, and validating in Azure portal.

Delete and re-provision databases to control monthly costs, using Terraform destroy or apply on targeted resources, and optionally comment out definitions before re-enabling when the course resumes.

Set up a NoSQL data infrastructure with Azure Cosmos DB by creating an account and database, configuring session consistency in west us, and deploying via Terraform plan and apply.

Provision an Azure storage account with Terraform, naming it storage_account_function in the West US region using the resource group, then run plan and apply and verify in the Azure portal.

Implement an Azure function resource with a dedicated app service plan and storage account, adjust Terraform configuration, and deploy resources to East Asia to resolve region constraints.

Deploy an event service stack with Azure Service Bus, Application Insights, and Key Vault via Terraform; use the Standard plan for topics and verify resources in the Azure portal.

Explore clean architecture with IPP project structure, detailing levels from user interface and API to core, infrastructure, and a test layer, and show data flow via persistence to external services.

Create a blank solution named bank in Visual Studio. Organize a src folder with microservice folders: bank gateway, bank transaction, bank balance, bank transfer, and bank notification.

Explore the development and communication of event-driven microservices using the Saga pattern, while applying clean architecture guidelines to stay aligned with this approach.

Create the bank gateway api project in asp.net core web api using dotnet 8. Organize clean architecture folders: domain with constants and entities, application with external, features, and models, endpoint.

Create a gateway API endpoint to receive transfer requests, modeling an endpoint with customer id, transfer amount, source and destination accounts, and map a post route that returns the model.

Test the API gateway with Postman by sending a bank transfer to the Send Transfer endpoint, and verify the response echoes the customer id, amount, source account, and destination account.

Create architecture by scaffolding a bank transaction API in ASP.NET Core and organizing the project into domain, persistence, external, application, and features folders.

Configure and secure the transaction database for the microservice by provisioning it in the Azure portal, enabling SQL authentication, whitelisting your IP, and creating the transaction table with key fields.

Create a transaction entity in the domain layer and configure a SQL Server EF Core database context with a DbSet, enabling save changes async and dependency injection.

Configure the Azure SQL balance database by connecting to the SQL server, enabling firewall rules, and creating the balance table with id, correlation_id, date, status, and customer_id.

Create the bank balance API by duplicating the transaction microservice, rename balance entities, update domain and persistence, install EF Core SQL Server, and configure the database service with user secrets.

Implement an integration test in a minimal API by wiring a database service, calling the async data interface, and displaying results in the browser to verify database integration.

Configure and create the transfer table in the SQL database for the transfer microservice via the Azure portal, firewall rules, and Terraform credentials.

Create a new bank transfer api project, copy the balanced microservice, rename entities to transfer, and configure ef core sql server with a secret connection string.

Demonstrates integration testing for a .NET microservice by wiring a database service into a minimal API, querying the transfer table asynchronously, and validating the database connection.

Create and implement the notification microservice in a .net and docker event-driven architecture, using cosmos db, a notification entity with json properties, and an asp.net core web api route.

Implement a Cosmos DB database service in a .NET API project. Configure connection string, database, and container, and provide add and get all methods using a cosmos client.

Run integration tests to save and retrieve a notification entity in Azure Cosmos DB, using the database service add async, then fetch and verify the persisted data.