Developing Scalable Solutions on Microservices with .NetCore

Explore microservices as small, autonomous services deployed and scaled independently, each owning its own database and enabling data encapsulation while using rest APIs, gRPC, or message brokers for communication.

Define microservices as a collection of small, independent, deployable services with their own databases and logic, and explore core principles for scalable, decoupled architectures.

Discover how microservices enable independent scaling, flexibility to use different technologies, and easier maintainability through isolated services, containers, and cloud platforms.

Explore the benefits of dotnet core for microservices, including cross-platform capability, container friendliness, and high performance. Leverage built-in dependency injection and asynchronous programming for modular, scalable, and secure APIs.

Explore ASP.NET Core as a cross-platform, high-performance framework for building lightweight, scalable APIs and microservices with built-in dependency injection, an open-source, community-driven middleware pipeline, and integrations like Swagger and gRPC.

Master dependency injection in ASP.NET Core to decouple components, improve testability, and leverage built-in lifetimes—singleton, scoped, and transient—registered via Program.cs for scalable microservices.

Explore how middleware in ASP.NET Core intercepts http requests in a pipeline, enabling logging, authentication, routing, and error handling, and learn how request delegates chain and short-circuit.

Build custom middleware in .net core microservices to extend the request pipeline with logging, authentication, and error handling, deciding when to pass control or return friendly errors.

Explore custom middlewares for scalable microservices in .NET Core, including logging, authentication, and error handling, and learn to register them in the pipeline with app.Use and JWT flows.

Learn how async and await enable non-blocking IO-bound operations to boost the scalability and responsiveness of web APIs by handling database calls, file access, and HTTP requests without blocking threads.

Set up the development environment with Visual Studio, choosing the enterprise version and ASP.NET web development workloads, install SDKs, and explore unit testing and Entity Framework basics.

Set up the development environment by installing SQL Server Management Studio and SQL Server 2019 locally, configure Windows authentication, and prepare the local database for microservices development.

Create an ASP.NET Core web API, learn REST concepts and HTTP methods, and secure with JWT for authentication and authorization; explore Visual Studio 2022 and the project structure.

Create web APIs using dotnet core, including api controllers, routing, rest api concepts, http methods such as get, post, put, and patch, https, and implement jwt-based authentication and authorization.

Configure JWT authentication in program.cs using a bearer token, setting token validation parameters, issuer, audience, lifetime, and a symmetric security key.

Learn to configure JWT bearer authentication and swagger integration in program.cs, including openapi security schemes, authorization headers, and token usage for secure microservice APIs.

Configure jwt in program.cs by adding open api security requirements and bearer security schemes, enabling authorization in swagger and preparing authentication components for dotnet core APIs.

Create an authentication controller and implement JWT authentication with custom Swagger configurations. Expose a post method get token returning IActionResult to issue tokens.

Create a login model class with username and password to enable JWT authentication, and configure routes and payloads that connect user input to the API controller.

Create and implement an authentication interface in a .NET Core microservices project, exposing JWT token generation methods and leveraging dependency injection for loosely coupled, reusable authentication logic.

Shows implementing authentication logic for request and response delegates in dotnet core by building a jwt with claims, a symmetric key, and signing credentials.

Implement JWT authentication logic for a .NET core microservices project, configuring issuer, audience, claims, expiration, and signing credentials to generate tokens and integrate with swagger.

Register and inject IAuthentication interface and its logic into services via dependency injection in program.cs. Demonstrate scope lifetimes and integrate authentication logic across BL and controller to issue JWT tokens.

Inject authentication logic into the authentication controller via dependency injection, creating a private read-only IAuthenticationLogic object, exposing a public interface, and wiring it through the dotnet core DI container.

Inject the I authentication logic interface into the controller via dependency injection, then call generate JWT token to return a bearer token.

Learn to generate a jwt token using a secret key, inspect its time, expiration, claims, and audience, and apply a bearer token to secure future microservice APIs.

Configure JWT token expiration in your .NET Core API by implementing a token response model and returning the token and expiration time to support bearer authorization.

Apply the IConfiguration interface to access settings in services and controllers. Create a central constant variables class to manage username, password, and secret key in a .NET Core microservices project.

Use the IConfiguration interface to load appsettings.json values (username, password, secret key) into static constants and wire them in Program.cs for centralized authentication and JWT usage.

Use the IConfiguration interface to fetch credentials from appsettings.json, replacing hard-coded username, password, and secret key with constant variables for JWT authentication across programs.

Learn to manage development, staging, and production environments by defining boolean environment variables in appsettings.json, wiring them to a static constant isProduction flag, and using it in controllers.

Explore environment specific configuration files and environment variables to manage staging and production settings. Diagnose and fix boolean type errors, test token generation, and verify app settings use across environments.

Demonstrate JWT token generation and authentication on swagger UI, validating responses, bearer token usage, and credential checks in a .NET Core Web API.

Build your first microservices API with dotnet core by implementing CRUD, defining routes for get, post, put, patch, and delete, and wiring SQL Server data access and authentication.

Define api controller and route to create a json-focused rest api in dotnet core, modeling an employee with id, first name, last name, email, and department, with automatic validation.

Implement an HTTP GET API method to return employee data in JSON using the employee model, enable authentication, and test via Swagger with hard-coded sample values.

Learn how to define an API controller and route that returns models as JSON, with GET methods and secured access via authorize and JWT tokens, plus status code handling.

Implement http status codes (400, 200, 500) in the employee controller, with try-catch handling and JWT-based authorization. Update program.cs and swagger to validate API responses.

Implement a data access layer in the web api using SQL data adapters, data tables, and data sets to bridge the database with in-memory data.

Implement a data access layer by creating a db access class that executes a parameterized sql query, opens a connection, and fills a data table with a sql data adapter.

Implement the data access layer for a web api by configuring sql connections and adapters, resolving package errors, and injecting db access with add scope in program.cs.

Implement the business logic layer by building an employee logic class that uses the data access layer to execute a SQL query and populate the employee model.

Develop and refine the get all employees data logic in the business logic layer, using database access via dependency injection and data rows to build employee models.

Create the I employee interface with a get all employees method, connect it to the employee model for DB access, and inject the interface via program.cs using add scoped.

Link models with controllers and the data access layer using dependency injection to fetch employee data from a database, replacing hard-coded values with a list of employee models.

Explore adding scope in program.cs using dependency injection, inject interfaces into controllers to access business logic, and understand object lifecycles and token-based authentication during debugging.

Learn dependency injection in controllers, call methods via constructor and interface, and implement a post method to add and fetch employee data, including transient scope concepts.

Register and inject the employee service into the controller using dependency injection, implement the add employee method with an employee model and interface wiring for future database integration.

Explore object-relational mapping and using Entity Framework Core to map web API models to SQL Server tables, generate SQL under the hood, and manage code-first migrations across microservices.

Learn to create a new database, map with an ORM via DbContext to SQL Server, fetch and configure a connection string in app settings, and install NuGet packages.

Learn to set up a SQL Server connection string in app settings, inject it via dependency injection and configuration, and retrieve it for db access.