Description

Deep Dive: Microservices Architecture

Microservices Architecture is one of the most popular software architectures. It is the de facto choice for any big company, and knowing how to create a system using it is crucial for any software developer who wants to work at a big company. However, it is a very complex topic with many nuances, edge cases, and caveats. In this course, AWS Solution Architect James Eastham will use the knowledge he gained building microservices for Amazon Web Services to teach you how to create an entire microservices architecture system. This course is both theory and code-heavy, with many diagrams and detailed explanations for every decision made. Join James on this journey and master Microservices Architecture today.

# Title Duration
1 Welcome 01:24
2 What will you learn in this course? 02:09
3 Who is the course for and prerequisites 03:58
4 Getting the most from this course 03:44
5 Introducing the Sample Application 03:35
6 How big is a microservice? 03:55
7 The current code-base 08:20
8 Your first microservice 05:33
9 Integrating your first microservice 02:55
10 Introducing integration tests 00:39
11 API First Design 07:34
12 Mocking microservice integrations 02:00
13 Run your microservices 03:56
14 Section Recap 02:48
15 Independent Testability 03:16
16 Defining the different types of tests 03:12
17 Unit testing a microservice 04:30
18 Integration testing a microservice 07:28
19 Contract testing inter-service communication 02:53
20 Break a contact, test the test 05:39
21 End to tests, good or bad? 07:04
22 Performance testing your service 05:03
23 Load testing your service 03:42
24 Section recap 02:31
25 Module Introduction 03:11
26 gRPC for inter-service communication 01:41
27 Deploying new services 01:13
28 Is a microservice a single process? 02:39
29 Your first gRPC microservice 02:20
30 Integration test your new service 03:43
31 Implement a gRPC client 01:37
32 Mocking gRPC for integration tests 04:10
33 End to end tests with gRPC 02:31
34 Dealing with failure in gRPC 03:48
35 Dealing with failure in REST 04:10
36 An Introduction to Service Discovery 02:35
37 Service Discovery with Consul 09:20
38 The Problem with Synchronous Communication 03:48
39 An Introduction to Asynchronous Communication 02:58
40 Technology Choices for Async Communication 02:02
41 Shared Code for Event Communication 00:39
42 Event Schemas and the CloudEvents Specification 01:13
43 Defining event subscribers 01:20
44 Publishing your first event 01:54
45 Consuling your first event 03:08
46 Asynchronous communication in action 01:41
47 Integration test with events 03:38
48 Libraries for message driven systems 00:48
49 Fault-tolerance in event driven systems 05:09
50 Implementing Idempotency 03:05
51 Asynchronous Communication Recap 01:13
52 Caching 08:51
53 Section Recap 01:17
54 The Strangler Fig Pattern for decomposition 05:00
55 Configure Nginx as a reverse proxy 02:52
56 Nginx in action 00:49
57 Breaking out the orders API 01:42
58 Breaking out inter-module communication 01:44
59 An event-first approach to decomposition 01:57
60 Handling events inside your monolith 02:29
61 Data Persistence during a migration 01:53
62 Monolith to microservices recap 02:39
63 Microservices architecture in action 01:12
64 Section Recap 01:26
65 Introduction to secure microservices 03:20
66 User Login for ASP.NET Microservices 04:48
67 Generating authentication tokens on user login 01:20
68 Users Authentication in Action 05:33
69 Using JWT claims inside your application 03:13
70 Integration testing secure microservices 04:08
71 Methods of Service to service authentication 04:10
72 Implementing service to service authentication 03:19
73 Section Recap 02:01
74 Introduction to scaling microservices 01:00
75 Platform engineering for deployment pipelines 03:56
76 Standardising deployment pipelines 02:14
77 Service blueprints for getting started 01:02
78 Discoverability in large-scale microservice architectures 01:33
79 Auto-generate documentation for async API’s 05:09
80 A Brief word on Backstage.IO 00:25
81 Considerations of microservices at scale 02:54
82 Course recap 01:22