Pragmatic Clean Architecture

Pragmatic Clean Architecture

English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 91 Lessons (6h 21m) | 1.61 GB

Confidently Build Production-Ready Apps Using Clean Architecture

This comprehensive course will teach you the system I use to ship production-ready applications using Clean Architecture. Learn how to apply the best practices of modern software architecture.

Everything You Need To Build Production-Ready Applications With Clean Architecture

Clean Architecture Deep-Dive

  • Learn the architectural principles to make better decisions
  • How to design applications that stand the test of time
  • Where should you use Clean Architecture

Build a Rich Domain Layer with DDD

  • A practical guide to using Domain-Driven Design
  • Learn the most important DDD tactical patterns
  • Best practices for designing a rich domain model

Clean Application Layer use cases

  • Learn how to implement clean use cases with CQRS
  • Solve cros-cutting concerns with ease
  • How to achieve blazing query speed

Powerful Infrastructure Layer

  • How to implement a blazing fast persistence layer
  • Get the most from advanced EF Core features
  • Learn how to solve concurrency issues

Elegant Presentation Layer

  • How to set up dependency injection the right way
  • Configuration management and documentation
  • Adding API and endpoints efficiently

Bulletproof Authentication

  • Implement robust JWT authentication to secure your API
  • Learn how to integrate an external identity provider
  • How to apply modern security best practices

Robust Authorization

  • Learn how to implement custom authorization policies
  • Role-based and permission-based authorization
  • Why you need resource-based authorization

Production-Ready Advanced Features

  • Structured logging, health checks, API versioning
  • Improve scalability with background jobs
  • Distributed caching with Redis

High-Quality Testing

  • Learn how to test complex systems the right way
  • Unit testing, Integration testing, Functional (E2E) testing
  • Enforce your software architecture with architecture tests

After Completing This Course You Will

  • Confidently use Clean Architecture to build amazing projects at your work
  • Build a rich domain model with Domain-Driven Design fundamentals
  • Set up production-ready applications with industry best practices
  • Understand the most important architectural principles
Table of Contents

1 Welcome
2 What you will learn in this course
3 Who this course is for
4 What are the prerequisites for taking this course
5 Architectural principles & Design principles
6 Clean Architecture layers
7 What we are building & why
8 Chapter recap
9 Introduction
10 Creating the Domain project
11 Defining our first domain entity
12 What is an Entity in Domain-Driven Design
13 Introducing Value Objects for solving primitive obsession
14 The importance of private setters in the domain model and encapsulation
15 Using the Static Factory pattern in the domain
16 Introducing the Domain Events pattern to the solution
17 Adding Repositories and the Unit of Work to the domain
18 Creating the Booking entity
19 Implementing a Domain service
20 Using Double Dispatch for a better domain model
21 Introducing the Result class to the project
22 Defining a dictionary of domain errors
23 Chapter recap
24 Introduction
25 Creating the Application project
26 Configuring dependency injection and installing MediatR
27 Adding the required abstractions for CQRS
28 Implementing Commands with the rich domain model & repositories
29 Defining a domain event handler
30 Implementing Queries with Dapper for blazing performance
31 Solving logging as a cross-cutting concern
32 Creating a Validation pipeline for commands
33 Chapter recap
34 Introduction
35 Creating the Infrastructure project
36 Configuring infrastructure services with dependency injection
37 Adding Entity Framework Core to the solution
38 Configuring Entity Framework Core with dependency injection
39 Creating the Domain entity configurations
40 Automatically applying entity configurations
41 Implementing repository interfaces using a generic repository
42 Implementing the SQL connection factory
43 Publishing domain events inside the Unit of Work
44 Solving race conditions with optimistic concurrency
45 Chapter recap
46 Introduction
47 Creating the Presentation project
48 Configuring services with dependency injection
49 Adding Controllers and endpoints
50 Setting up Docker Compose and running the API
51 Creating EF migrations and applying them
52 Seeding initial data
53 Adding Middleware – Global exception handler
54 Demo Presentation layer & API
55 Chapter recap
56 Introduction
57 Keycloak identity provider setup
58 Keycloak admin panel overview
59 Demo Obtaining JWTs using Keycloak
60 Configuring authentication middleware & services
61 Configuring JWT authentication options
62 Demo Authentication in action
63 Implementing the user registration feature
64 Adding an API endpoint for registering a user
65 Implementing the authentication service
66 Configuring the authentication service as a typed HTTP client
67 Demo User registration with Keycloak
68 Implementing the user login feature
69 Demo User login with Keycloak
70 Chapter recap
71 Introduction
72 Implementing Role-based Authorization
73 Implementing Permission-based Authorization
74 Implementing Resource-based Authorization
75 Chapter recap
76 Introduction
77 Structured Logging with Serilog and Seq
78 Distributed Caching with Redis
79 Health Checks in Clean Architecture
80 Implementing API Versioning
81 Transactional Outbox Pattern
82 Minimal APIs
83 Chapter recap
84 Introduction
85 Domain Layer Unit Testing
86 Application Layer Unit Testing
87 Integration Testing
88 Functional Testing
89 Architecture Testing
90 Chapter recap
91 One Small Ask From Me