Advanced Microservices with .NET: Development & Azure Deploy

Define application actions for create, read, update, and delete and build a permission model with a helper that creates strings like permission.identity.users.create from service, feature, and action, including group-based roles.

Define and organize app permissions using a public EB role group, then build identity permissions for the users feature, roles, and role claims with CRUD actions in system access grouping.

Create a custom authorize attribute in the attributes folder to enable permission based authorization by composing permissions from service, feature, and action and mapping them to a policy.

Build a lightweight response library to host cross-cutting models, including a response wrapper, centralized event definitions for service bus publishing, and custom exceptions for global handling across services.

Implement non-generic response wrappers in a .NET microservices context by creating a public class that implements interfaces, with fail and success helpers, and synchronous and asynchronous overloads for messaging.

Develop a generic api response wrapper in .NET by extending the base response wrapper, implementing data properties, and adding synchronous and asynchronous fail and success methods with optional messages.

Learn to build an identity service for microservices with .NET, enabling user CRUD, roles and claims, login with JWT, and a gateway using EF Core, CQRS with mediator, and FluentValidation.

Build a clean-architecture identity service in .NET by creating layered projects (application, infrastructure, web API) and planning microservices with independent repositories and an API gateway.

Install essential packages in the application and infrastructure layers, including mediator, mapster, flow and validation, and dependency injection, then configure entity framework core identity with sql server for dotnet eight.

Build a startup extension to register the application db context via dependency injection, read the default connection string, and configure EF core with migrations history and retry logic.

Design and implement identity service request and response models for API integration, using an API gateway, a response wrapper, and a shared NuGet package for front-end and back-end use.

Implement a user registration command with mediator, create a user registration request and a handler implementing IRequestHandler with an asynchronous handle method to register a user via a dedicated interface.

Implement get user by id in a .NET microservice, fetch the user from the database, map to a user response DTO, and return a success or not-found result.

Implement get user roles async by injecting the role manager, retrieving all roles, and marking which are assigned to the user in a list of user role view models.

Implement get permission async to return all permissions from constants, flag those assigned to a role, validate a role, and map role claims into role claim response using OAuth library.

Build role management with commands and queries using mediator requests, implementing create, update, delete, and update role permissions commands with dedicated handlers and a role service, returning response wrappers.

Register identity and role services in the infrastructure layer via a startup extension, wiring IUserService and IRoleService as transient dependencies and exposing them to the web API with identity services.

Add a transient database seeder to the dependency injection pipeline by creating a startup extension on the web API, resolving ApplicationDbContext and running SeedIdentityDatabase asynchronously in development.

Implement a refresh token flow by validating expired tokens with configured issuer, audience, and signing key, extracting claim principals to issue a new json web token via a private helper.

Login test returns 200 with a jwt and refresh token, detailing user claims, roles, and permissions. Protect endpoints with the authorize attribute and test token-based access via swagger.

Create a roles controller with endpoints to create, delete, update roles and update role permissions, plus get role by id, get all roles, and get permissions for a role.

Demonstrate role controller endpoints for create, get all, get by id, update, and delete, protected by permissions, and show role permission queries and updates in the ASP.Net identity context.

Explore user request validation in a clean architecture identity service using fluent validation and MediatR pipeline behavior, comparing validation without and with the mediator pipeline for the user registration endpoint.

Develop an api gateway with ocelot to centralize access to the identity service and microservices, validate tokens with JWT bearer, forward headers, and implement retries with Polly and custom middleware.

Create a new api gateway project in Visual Studio with dotnet eight, remove swagger and controllers, adjust program.cs and endpoints, and prep to install the required packages for deployment.

Define upstream and downstream routing in an api gateway to expose a login endpoint that forwards to the identity service, using https, a post method, and route paths like /auth/login.

test a user registration endpoint with postman by sending a post request to the identity service behind an api gateway, using a jwt bearer token and json body.

Demonstrates how the API gateway handles a down identity service by replacing 502 with a custom middleware that throws a service unavailable exception and returns a global 503 response.

Create a private static helper to derive the downstream domain from the HTTP context by reading downstream routes and assembling scheme, host, and port for API gateway routing.

Review the architectural diagram and mark completed components, the gateway and identity service are functional and pushed to the repo. Begin phase two by starting development of a service.

Install EF Core packages for SQL Server in dotnet eight: Microsoft Entity Framework Core, design, SQL Server, and tools. Then create the DB context to enable database creation and interaction.

Create the application db context with entity framework core, define db sets for Brent, product, and images, and register it via dependency injection using the default connection string.

Refactor the brand service to move product existence checks and property mapping to the application layer, while the service layer's update async uses the DbContext to update and save.

Use fluent validation to require brand name and description, and copy the identity service validation pipeline into the application layer with IValidateMe and mediator.

Test and validate the create brand command within a .NET microservice pipeline by inspecting requests, applying the create brand command validator, and handling 400 errors or successful database creation.

implement authorization in the product service by validating json web tokens, wiring token settings, and integrating a permission-based policy provider and authorization handler with swagger security.

Configure the API gateway to expose product service endpoints (create product, add brand, update brand), forward JWT in the authorization header, and configure Postman tests.

Validate token-based configuration across product, identity, and API gateway services, log in as admin, verify permissions with jwt.io, and create a brand via secured endpoints using the authorization token.

Commit all changes and push the branch to enable collaboration in a shared source control environment. Review identity service updates and package changes, then focus on the product service.

Protect the product creation endpoint by enforcing permissions and forwarding the JSON web token through the API gateway to the product service feature products create endpoint, and test with Postman.

Test product creation in postman against a brand foreign key, verifying empty or non-existent brand IDs trigger validation errors and showing all validations at once.

Implement a delete product command and endpoint by looking up the product, deleting asynchronously via the service, and returning a success or failure message in a response wrapper.

Develop and test a get product by id endpoint secured with read permission, using mediator queries and a downstream gateway, validated by postman; plan Redis cache and RabbitMQ.

Add and bind cache settings in appsettings, configure them via an IServiceCollection extension, and register a Redis cache in program.cs with a 5-minute sliding expiration for the product service.

Assess cache behavior for get all products by validating cache writes, sliding and absolute expiration, and using the cache aside pattern to read from cache instead of the database.

Configure rabbitmq in the dependency injection container using mass transit, connect to a local rabbitmq host with guest credentials, inside a .NET web api startup.

Defines and implements a public inventory item service for bulk creation, retrieval, status updates, and deletion, then wires it into dependency injection and configures it in program startup.

Prepare dependency injection by creating a startup extension to add MediatR, resolving assemblies, and wiring mediator into the service container. Configure the consumer to publish messages to RabbitMQ on localhost.

Implement the inventory delete item command with a request handler that calls delete item asynchronously, returns the removed item id, and uses a response wrapper via a controller endpoint.

Run and test the change inventory item status command, update an item to on hold, verify the status via get by id, and outline creating a single-item deletion endpoint.

update the inventory item response model to include the product object by a synchronous call from the inventory service to the product service, enabling eager loading of product details.

Define and implement GetProductByIdAsync to call the product service by id, fetch product details, and attach them to the inventory item response.

Move rabbitmq host, user, password, and receive endpoints from magic strings into configuration, bind them to a rabbitmq settings model, and inject via DI for configurable retries.

Set up a blank solution in Visual Studio for a notification service, building domain, application, infrastructure, and web API projects with an endpoint to retrieve sent emails.

Configure EF Core ORM in microservices by installing EF packages, defining a DB context, wiring DI, and running migrations to create a notifications table in the notification DB.

Design and implement a create notification command within the application layer using MediatR, defining a command, handler, and response wrapper for notification creation in the naughty vacations feature.

Sign up for SendGrid and integrate it with a dotnet web api using c sharp, create and secure an api key, and enable sender authentication.

Demonstrates end-to-end email notifications for a new product, showing login, product creation, event publishing, email sending with SendGrid, and message consumption by inventory and notification services.

Test the email notification entry to database by sending emails and confirming they are logged as records in the database.

Learn to set up CI/CD pipelines with Azure DevOps, manage organization and project settings, and enable release pipelines for build and deployment.

Add custom configurations in a production release by modifying Azure DevOps deployment tasks, including token settings, expiry, refresh token expiry, app settings, and connection strings for the identity service.

Add the default connection string in the release pipeline, sourced from the identity database. Hide credentials in the pipeline and enable Azure deployment with environment-variable seed logic.

This lecture demonstrates configuring the product service with service bus topic, Azure Redis Cache, environment variables and connection strings, and validating deployments via CI/CD pipelines.

Test the product service end-to-end by authenticating via swagger, creating a brand and a product, and publishing events to service bus; verify Redis cache integration.

Set up an Azure DevOps ci/cd pipeline for the inventory service, restore and build, publish artifacts, and deploy to Azure app service with service bus and environment variables.

Illustrate how a service bus topic broadcasts to multiple subscribers, and how filters keep each subscription aligned with relevant events, using dead letter queue for failed message processing.