Section 1 : Fundamental Ideas Around Microservices

Lecture 1 INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM Pdf
Lecture 2 About Certification Pdf
Lecture 2 Course Resources Text
Lecture 4 What Is a Microservice 3:19
Lecture 5 Data in Microservices 7:34
Lecture 6 Big Problems with Data 5:8
Lecture 7 Sync Communication Between Services 6:53
Lecture 8 Event-Based Communication 5:19
Lecture 9 A Crazy Way of Storing Data 9:48
Lecture 10 Pros and Cons of Async Communication 6:15

Section 2 : A Mini-Microservices App

Lecture 11 App Overview 5:43
Lecture 12 Project Setup 4:57
Lecture 13 Posts Service Creation 8:18
Lecture 14 Testing the Posts Service 4:4
Lecture 15 Implementing a Comments Service 8:22
Lecture 16 Quick Comments Test 3:57
Lecture 17 Note on the React App Text
Lecture 18 Suggestion Regarding a Default Export Warning Text
Lecture 19 React Project Setup 5:0
Lecture 20 Building Post Submission 9:54
Lecture 20 building-post Zip
Lecture 21 Handling CORS Errors 4:8
Lecture 22 Fetching and Rendering Posts 10:4
Lecture 23 Creating Comments 8:9
Lecture 24 Displaying Comments 7:23
Lecture 25 Completed React App Text
Lecture 26 Request Minimization Strategies 4:54
Lecture 27 An Async Solution 7:16
Lecture 28 Common Questions Around Async Events 4:14
Lecture 29 Event Bus Overview 5:14
Lecture 30 Important Note about Node v15 and Unhandled Promise Rejections Text
Lecture 31 A Basic Event Bus Implementation 5:22
Lecture 32 Emitting Events 5:18
Lecture 33 Emitting Comment Creation Events 3:45
Lecture 34 Receiving Events 4:32
Lecture 35 Creating the Data Query Service 4:42
Lecture 36 Parsing Incoming Events 7:2
Lecture 37 Using the Query Service 7:9
Lecture 38 Adding a Simple Feature 4:46
Lecture 39 Issues with Comment Filtering 7:43
Lecture 40 A Second Approach 5:37
Lecture 41 How to Handle Resource Updates 4:45
Lecture 42 Creating the Moderation Service 4:52
Lecture 43 Adding Comment Moderation 4:26
Lecture 44 Reminder about Node v15 and Error Catching Text
Lecture 45 Handling Moderation 5:29
Lecture 46 Updating Comment Content 4:58
Lecture 47 A Quick Test 5:57
Lecture 48 Rendering Comments by Status 3:26
Lecture 49 Dealing with Missing Events 10:23
Lecture 50 Required Node v15+ Update for Query Service Text
Lecture 51 Implementing Event Sync 6:11
Lecture 52 Event Syncing in Action 4:16

Section 3 : Running Services with Docker

Lecture 53 Deployment Issues 6:55
Lecture 54 Why Docker 2:55
Lecture 55 Why Kubernetes 5:47
Lecture 56 Don't Know Docker Watch This 1:17
Lecture 57 Note About Docker Build Output and Buildkit Text
Lecture 58 Dockerizing the Posts Service 4:2
Lecture 59 Review Some Basic Commands 5:23
Lecture 60 Dockering Other Services 3:0

Section 4 : Orchestrating Collections of Services with Kubernetes

Lecture 61 Installing Kubernetes 3:19
Lecture 62 IMPORTANT Note for Minikube and MicroK8s Users Text
Lecture 63 A Kubernetes Tour 9:45
Lecture 64 Important Kubernetes Terminology 2:51
Lecture 65 Notes on Config Files 3:11
Lecture 66 Creating a Pod 6:41
Lecture 67 ErrImagePull, ErrImageNeverPull and ImagePullBackoff Errors Text
Lecture 68 Understanding a Pod Spec 5:15
Lecture 69 Common Kubectl Commands 4:44
Lecture 70 A Time-Saving Alias 2:26
Lecture 71 Introducing Deployments 3:27
Lecture 72 Creating a Deployment 6:11
Lecture 73 Common Commands Around Deployments 4:35
Lecture 74 Updating Deployments 6:2
Lecture 75 Preferred Method for Updating Deployments 5:42
Lecture 76 Networking With Services 4:15
Lecture 77 Creating a NodePort Service 7:52
Lecture 78 Accessing NodePort Services 5:9
Lecture 79 Setting Up Cluster IP Services 3:12
Lecture 80 Building a Deployment for the Event Bus 5:35
Lecture 81 Adding ClusterIP Services 7:37
Lecture 82 How to Communicate Between Services 4:9
Lecture 83 Updating Service Addresses 6:27
Lecture 84 Verifying Communication 5:0
Lecture 85 Adding Query, Moderation and Comments 9:57
Lecture 86 Testing Communication 5:29
Lecture 87 Load Balancer Services 5:13
Lecture 88 Load Balancers and Ingress 6:38
Lecture 89 Update on Ingress Nginx Mandatory Commands Text
Lecture 90 Installing Ingress-Nginx 7:40
Lecture 91 Ingress v1 API Required Update Text
Lecture 92 Writing Ingress Config Files 4:47
Lecture 93 Important Note About Port 80 Text
Lecture 94 Hosts File Tweak 6:15
Lecture 95 Important Note to Add Environment Variable Text
Lecture 96 Deploying the React App 6:9
Lecture 97 Unique Route Paths 6:55
Lecture 98 Final Route Config 6:32
Lecture 99 Introducing Skaffold 3:8
Lecture 100 Skaffold Setup 9:17
Lecture 101 First Time Skaffold Startup 1:0
Lecture 102 A Few Notes on Skaffold 6:30

Section 5 : Architecture of Multi-Service Apps

Lecture 103 Big Ticket Items 15:11
Lecture 104 App Overview 8:53
Lecture 105 Resource Types 3:23
Lecture 106 Service Types 3:37
Lecture 107 Note on Typescript Text
Lecture 108 Events and Architecture Design 3:48
Lecture 109 Auth Service Setup 4:50
Lecture 110 Auth K8s Setup
Lecture 111 Note on Code Reloading Text
Lecture 112 Ingress v1 API Required Update Text
Lecture 113 Adding Skaffold 5:36
Lecture 114 Ingress-Nginx Setup 7:19
Lecture 115 Hosts File and Security Warning 4:5

Section 6 : Leveraging a Cloud Environment for Development

Lecture 116 Note on Remote Development 2:51
Lecture 117 Remote Dev with Skaffold 6:35
Lecture 118 Free Google Cloud Credits Text
Lecture 119 Google Cloud Initial Setup 2:43
Lecture 120 Kubernetes Cluster Creation 3:59
Lecture 121 Kubectl Contexts 3:49
Lecture 122 Initializing the GCloud SDK 5:3
Lecture 123 Installing the GCloud Context 4:17
Lecture 124 Updating the Skaffold Config 4:34
Lecture 125 More Skaffold Updates 1:6
Lecture 126 Creating a Load Balancer 5:12
Lecture 127 Final Config and Test 6:25

Section 7 : Response Normalization Strategies

Lecture 128 Creating Route Handlers 5:40
Lecture 129 Scaffolding Routes 4:5
Lecture 130 Adding Validation 8:38
Lecture 131 Handling Validation Errors 6:18
Lecture 132 Postman HTTPS Issues Text
Lecture 133 Surprising Complexity Around Errors 6:6
Lecture 134 Other Sources of Errors 4:17
Lecture 135 Solution for Error Handling 4:50
Lecture 136 Building an Error Handling Middleware 7:38
Lecture 137 Communicating More Info to the Error Handler 5:23
Lecture 138 Encoding More Information In an Error 4:35
Lecture 139 Subclassing for Custom Errors 8:17
Lecture 140 Determining Error Type 3:10
Lecture 141 Converting Errors to Responses 10:12
Lecture 142 Moving Logic Into Errors 8:36
Lecture 143 Verifying Our Custom Errors
Lecture 144 Final Error Related Code 10:19
Lecture 145 How to Define New Custom Errors 5:1
Lecture 146 Uh Oh 5:49

Section 8 : Database Management and Modeling

Lecture 147 Creating Databases in Kubernetes 8:25
Lecture 148 Connecting to MongoDB 7:53
Lecture 149 Understanding the Signup Flow 4:25
Lecture 150 Getting TypeScript and Mongoose to Cooperate 5:21
Lecture 151 Creating the User Model 4:54
Lecture 152 Type Checking User Properties 6:1
Lecture 153 Adding Static Properties to a Model 6:0
Lecture 154 Defining Extra Document Properties 4:53
Lecture 155 What's That Angle Bracket For 3:52
Lecture 156 User Creation 6:47
Lecture 157 Proper Error Handling 7:25
Lecture 158 Note on Password Hashing Text
Lecture 159 Reminder on Password Hashing 4:58
Lecture 160 Adding Password Hashing 6:57
Lecture 161 Comparing Hashed Password 2:54
Lecture 162 Mongoose Pre-Save Hooks 5:53

Section 9 : Authentication Strategies and Options

Lecture 163 Fundamental Authentication Strategies 8:58
Lecture 164 Huge Issues with Authentication Strategies 7:32
Lecture 165 So Which Option 2:58
Lecture 166 Solving Issues with Option #2 8:26
Lecture 167 Reminder on Cookies vs JWT's 6:21
Lecture 168 Microservices Auth Requirements 11:0
Lecture 169 Issues with JWT's and Server Side Rendering
Lecture 170 Cookies and Encryption 4:51
Lecture 171 Adding Session Support 3:11
Lecture 172 Generating a JWT 8:29
Lecture 173 JWT Signing Keys 4:56
Lecture 174 Securely Storing Secrets with Kubernetes 2:13
Lecture 175 Creating and Accessing Secrets 9:18
Lecture 176 Accessing Env Variables in a Pod 5:18
Lecture 177 Common Response Properties 4:41
Lecture 178 Formatting JSON Properties 10:38
Lecture 179 The Signin Flow 7:49
Lecture 180 Common Request Validation Middleware 5:33
Lecture 181 Sign In Logic 6:49
Lecture 182 Quick Sign In Test 1:53
Lecture 183 Current User Handler 3:1
Lecture 184 Returning the Current User 8:55
Lecture 185 Signing Out 2:48
Lecture 186 Creating a Current User Middleware 6:55
Lecture 187 Augmenting Type Definitions 7:46
Lecture 188 Requiring Auth for Route Access 7:46

Section 10 : Testing Isolated Microservices

Lecture 189 Scope of Testing 4:28
Lecture 190 Testing Goals 4:32
Lecture 191 Testing Architecture 7:51
Lecture 192 Index to App Refactor 2:54
Lecture 193 A Few Dependencies 3:33
Lecture 194 Test Environment Setup 8:11
Lecture 195 Our First Test 6:24
Lecture 196 An Important Note 1:31
Lecture 197 Testing Invalid Input 5:13
Lecture 198 Requiring Unique Emails 1:45
Lecture 199 Changing Node Env During Tests 5:43
Lecture 200 Tests Around Sign In Functionality 6:26
Lecture 201 Testing Sign Out 4:31
Lecture 202 Issues with Cookies During Testing 5:18
Lecture 203 Easy Auth Solution 3:3
Lecture 204 globalThis has no index signature TS Error Text
Lecture 205 Auth Helper Function 7:12
Lecture 206 Testing Non-Authed Requests 1:44

Section 11 : Integrating a Server-Side-Rendered React App

Lecture 207 Starting the React App 2:11
Lecture 208 Reminder on Server Side Rendering 3:38
Lecture 209 Suggestion Regarding a Default Export Warning Text
Lecture 210 Basics of Next JS 5:24
Lecture 211 Building a Next Image 4:28
Lecture 212 Running Next in Kubernetes 10:12
Lecture 213 Note on File Change Detection 4:26
Lecture 214 Adding Global CSS 5:9
Lecture 215 Adding a Sign Up Form 3:11
Lecture 216 Handling Email and Password Inputs 3:42
Lecture 217 Successful Account Signup 5:12
Lecture 218 Handling Validation Errors 6:53
Lecture 219 The useRequest Hook 6:59
Lecture 220 Using the useRequest Hook 3:40
Lecture 221 An onSuccess Callback 5:37
Lecture 222 Overview on Server Side Rendering 6:47
Lecture 223 A note about ECONNREFUSED errors Text
Lecture 224 Fetching Data During SSR 5:7
Lecture 225 Why the Error 9:0
Lecture 226 Two Possible Solutions 7:4
Lecture 227 Cross Namespace Service Communication 7:45
Lecture 228 When is GetInitialProps Called 6:46
Lecture 229 On the Server or the Browser 2:1
Lecture 230 Ingress-Nginx Namespace and Service - Important Update Text
Lecture 231 Specifying the Host 8:23
Lecture 232 Passing Through the Cookies 4:0
Lecture 233 A Reusable API Client 7:5
Lecture 234 Content on the Landing Page 2:1
Lecture 235 The Sign In Form 3:11
Lecture 236 A Reusable Header 5:0
Lecture 237 Moving GetInitialProps 2:11
Lecture 238 Issues with Custom App GetInitialProps 6:41
Lecture 239 Handling Multiple GetInitialProps 6:7
Lecture 240 Passing Props Through 3:3
Lecture 241 Building the Header 5:5
Lecture 242 Conditionally Showing Links 5:58
Lecture 243 Signing Out 4:36
Lecture 244 React App Catchup Text

Section 12 : Code Sharing and Reuse Between Services

Lecture 245 Shared Logic Between Services 4:34
Lecture 246 Options for Code Sharing 4:46
Lecture 247 NPM Organizations 4:27
Lecture 248 Publishing NPM Modules 4:6
Lecture 249 Project Setup 7:34
Lecture 250 Typo in package Text
Lecture 251 An Easy Publish Command 7:26
Lecture 252 Relocating Shared Code 7:29
Lecture 253 Updating Import Statements 5:16
Lecture 254 Updating the Common Module 5:34

Section 13 : Create-Read-Update-Destroy Server Setup

Lecture 255 Ticketing Service Overview 3:2
Lecture 256 Project Setup 5:24
Lecture 257 Running the Ticket Service 6:4
Lecture 258 Mongo Connection URI 8:13
Lecture 259 Quick Auth Update 1:47
Lecture 260 Test-First Approach 4:19
Lecture 261 Creating the Router 4:56
Lecture 262 Adding Auth Protection 8:4
Lecture 263 Faking Authentication During Tests 7:9
Lecture 264 globalThis has no index signature TS Error Text
Lecture 265 Building a Session 5:39
Lecture 266 Testing Request Validation 4:12
Lecture 267 Validating Title and Price 4:9
Lecture 268 Reminder on Mongoose with TypeScript 7:11
Lecture 269 Defining the Ticket Model 3:48
Lecture 270 Creation via Route Handler 8:21
Lecture 271 Testing Show Routes 6:52
Lecture 272 Unexpected Failure! 5:29
Lecture 273 What's that Error! 8:57
Lecture 274 Better Error Logging 5:11
Lecture 275 Complete Index Route Implementation 6:31
Lecture 276 Ticket Updating 6:14
Lecture 277 Handling Updates 4:15
Lecture 278 Permission Checking 6:49
Lecture 279 Final Update Changes 9:4
Lecture 280 Manual Testing 5:36

Section 14 : NATS Streaming Server - An Event Bus Implementation

Lecture 281 What Now 2:50
Lecture 282 Three Important Items 4:34
Lecture 283 Creating a NATS Streaming Deployment 6:25
Lecture 284 Big Notes on NATS Streaming 0:0
Lecture 285 Building a NATS Test Project 7:31
Lecture 286 Port-Forwarding with Kubectl 4:40
Lecture 287 Publishing Events 0:0
Lecture 288 mall Required Command Change Text
Lecture 289 Listening For Data 6:55
Lecture 290 Accessing Event Data 6:56
Lecture 291 Client ID Generation 4:48
Lecture 292 Queue Groups 7:28
Lecture 293 Manual Ack Mode 9:51
Lecture 294 Client Health Checks 9:45
Lecture 295 Graceful Client Shutdown 0:0
Lecture 296 Core Concurrency Issues 12:55
Lecture 297 Common Questions 8:8
Lecture 298 [Optional] More Possible Concurrency Solutions 16:42
Lecture 299 Solving Concurrency Issues 20:5
Lecture 300 Concurrency Control with the Tickets App 9:40
Lecture 301 Event Redelivery 4:34
Lecture 302 Durable Subscriptions 8:59

Section 15 : Connecting to NATS in a Node JS World

Lecture 303 Reusable NATS Listeners 4:32
Lecture 304 The Listener Abstract Class 9:27
Lecture 305 Extending the Listener 5:53
Lecture 306 Quick Refactor 3:17
Lecture 307 Leveraging TypeScript for Listener Validation 5:28
Lecture 308 Subjects Enum 3:28
Lecture 309 Custom Event Interface 2:26
Lecture 310 Enforcing Listener Subjects 7:22
Lecture 311 Quick Note 'readonly' in Typescript Text
Lecture 312 Enforcing Data Types 3:53
Lecture 313 Where Does this Get Used 2:49
Lecture 314 Custom Publisher 8:11
Lecture 315 Using the Custom Publisher 3:49
Lecture 316 Awaiting Event Publication 4:27
Lecture 317 Common Event Definitions Summary 6:26
Lecture 318 Updating the Common Module 7:35
Lecture 319 Restarting NATS 2:9

Section 16 : Managing a NATS Client

Lecture 320 Publishing Ticket Creation 3:48
Lecture 321 More on Publishing 3:19
Lecture 322 NATS Client Singleton 5:24
Lecture 323 Remember Mongoose 4:57
Lecture 324 TS Error - Did you forget to include 'void' in your type argument Text
Lecture 325 Singleton Implementation 9:4
Lecture 326 Accessing the NATS Client 4:28
Lecture 327 Graceful Shutdown 6:55
Lecture 328 Successful Listen! 3:23
Lecture 329 Ticket Update Publishing 4:28
Lecture 330 Failed Event Publishing 7:3
Lecture 331 Handling Publish Failures 6:2
Lecture 332 Fixing a Few Tests 3:52
Lecture 333 Redirecting Imports 5:35
Lecture 334 Providing a Mock Implementation 9:9
Lecture 335 Test-Suite Wide Mocks 2:12
Lecture 336 Ensuring Mock Invocations 9:13
Lecture 337 NATS Env Variables 8:0

Section 17 : Cross-Service Data Replication In Action

Lecture 338 The Orders Service 5:2
Lecture 339 Scaffolding the Orders Service 4:39
Lecture 340 A Touch More Setup 7:32
Lecture 341 Ingress Routing Rules 1:53
Lecture 342 Scaffolding a Few Route Handlers 9:55
Lecture 343 Subtle Service Coupling 6:43
Lecture 344 Associating Orders and Tickets 6:49
Lecture 345 Order Model Setup 8:52
Lecture 346 The Need for an Enum 5:55
Lecture 347 Creating an Order Status Enum 8:31
Lecture 348 More on Mongoose Refs 2:58
Lecture 349 Defining the Ticket Model 7:9
Lecture 350 Order Creation Logic 5:45
Lecture 351 Finding Reserved Tickets 6:10
Lecture 352 Convenience Document Methods 7:37
Lecture 353 Order Expiration Times 6:5
Lecture 354 globalThis has no index signature TS Error Text
Lecture 355 Test Suite Setup 2:36
Lecture 356 Type 'Documentany, any' is not assignable Error Text
Lecture 357 Asserting Tickets Exist 6:8
Lecture 358 Asserting Reserved Tickets 5:5
Lecture 359 Testing the Success Case 4:9
Lecture 360 Fetching a User's Orders 5:23
Lecture 361 A Slightly Complicated Test 12:23
Lecture 362 Fetching Individual Orders 4:36
Lecture 363 Does Fetching Work 7:17
Lecture 364 Cancelling an Order 4:32
Lecture 365 Can We Cancel 9:12

Section 18 : Understanding Event Flow

Lecture 366 Orders Service Events 4:42
Lecture 367 Creating the Events 9:23
Lecture 368 Implementing the Publishers 3:13
Lecture 369 Publishing the Order Creation 5:3
Lecture 370 Publishing Order Cancellation 2:33
Lecture 371 Testing Event Publishing 5:32

Section 19 : Listening for Events and Handling Concurrency Issues

Lecture 372 Time for Listeners! 2:12
Lecture 373 Reminder on Listeners 1:53
Lecture 374 Blueprint for Listeners 3:39
Lecture 375 A Few More Reminders 5:26
Lecture 376 Simple onMessage Implementation 2:17
Lecture 377 ID Adjustment 5:44
Lecture 378 Ticket Updated Listener Implementation 4:32
Lecture 379 Initializing the Listeners 2:44
Lecture 380 A Quick Manual Test 3:16
Lecture 381 Clear Concurrency Issues 12:59
Lecture 382 Reminder on Versioning Records 6:41
Lecture 383 Optimistic Concurrency Control 5:37
Lecture 384 Mongoose Update-If-Current 3:46
Lecture 385 Implementing OCC with Mongoose 4:2
Lecture 386 Test functions cannot both take a 'done' callback and return something Error Text
Lecture 387 Testing OCC 9:7
Lecture 388 One More Test 3:45
Lecture 389 Who Updates Versions 6:29
Lecture 390 Including Versions in Events 2:59
Lecture 391 Updating Tickets Event Definitions 3:55
Lecture 392 Property 'version' is missing TS Errors After Running Skaffold Text
Lecture 393 Applying a Version Query 7:14
Lecture 394 Did it Work 4:31
Lecture 395 Abstracted Query Method 5:42
Lecture 396 [Optional] Versioning Without Update-If-Current 18:34
Lecture 397 Testing Listeners 4:55
Lecture 398 A Complete Listener Test 9:25
Lecture 399 Testing the Ack Call 2:9
Lecture 400 Testing the Ticket Updated Listener 8:20
Lecture 401 Success Case Testing 4:49
Lecture 402 Out-Of-Order Events 4:51
Lecture 403 The Next Few Videos 3:39
Lecture 404 Fixing a Few Tests 6:36
Lecture 405 Listeners in the Tickets Service 1:47
Lecture 406 Building the Listener 4:59
Lecture 407 Strategies for Locking a Ticket 5:28
Lecture 408 Reserving a Ticket 3:41
Lecture 409 Setup for Testing Reservation 6:59
Lecture 410 Test Implementation 4:29
Lecture 411 Missing Update Event 6:14
Lecture 412 Private vs Protected Properties 6:54
Lecture 413 Publishing While Listening 6:42
Lecture 414 Mock Function Arguments 9:49
Lecture 415 Order Cancelled Listener 6:51
Lecture 416 A Lightning-Quick Test 7:28
Lecture 417 Don't Forget to Listen! 2:21
Lecture 418 Rejecting Edits of Reserved Tickets 6:15

Section 20 : Worker Services

Lecture 419 The Expiration Service 2:38
Lecture 420 Expiration Options 7:55
Lecture 421 Initial Setup 6:14
Lecture 422 Skaffold errors - Expiration Image Can't be Pulled Text
Lecture 423 A Touch of Kubernetes Setup 7:43
Lecture 424 File Sync Setup 2:32
Lecture 425 Listener Creation 3:42
Lecture 426 What's Bull All About 3:56
Lecture 427 Creating a Queue 9:7
Lecture 428 Queueing a Job on Event Arrival 5:9
Lecture 429 Testing Job Processing 3:17
Lecture 430 Delaying Job Processing 5:23
Lecture 431 Defining the Expiration Complete Event 3:50
Lecture 432 Publishing an Event on Job Processing 6:27
Lecture 433 Handling an Expiration Event 6:0
Lecture 434 Emitting the Order Cancelled Event 5:37
Lecture 435 Testing the Expiration Complete Listener 5:51
Lecture 436 A Touch More Testing 7:20
Lecture 437 Listening for Expiration 2:20

Section 21 : Handling Payments

Lecture 438 The Payments Service 2:11
Lecture 439 globalThis has no index signature TS Error Text
Lecture 440 Initial Setup 8:45
Lecture 441 Replicated Fields 5:57
Lecture 442 Another Order Model! 7:29
Lecture 443 Update-If-Current 1:17
Lecture 444 Replicating Orders 4:7
Lecture 445 Testing Order Creation 6:12
Lecture 446 Marking an Order as Cancelled 5:39
Lecture 447 Cancelled Testing 6:42
Lecture 448 Starting the Listeners 3:54
Lecture 449 Payments Flow with Stripe 5:10
Lecture 450 Implementing the Create Charge Handler 8:32
Lecture 451 Validating Order Payment 4:3
Lecture 452 Testing Order Validation Before Payment 6:59
Lecture 453 Testing Same-User Validation 5:10
Lecture 454 Stripe Setup 3:58
Lecture 455 Creating a Stripe Secret 3:19
Lecture 456 Creating a Charge with Stripe 6:8
Lecture 457 Manual Testing of Payments 6:35
Lecture 458 Automated Payment Testing 6:26
Lecture 459 Mocked Stripe Client 4:23
Lecture 460 A More Realistic Test Setup 9:16
Lecture 461 Realistic Test Implementation 6:15
Lecture 462 Tying an Order and Charge Together 7:18
Lecture 463 Testing Payment Creation 6:13
Lecture 464 Publishing a Payment Created Event 6:31
Lecture 465 More on Publishing 3:18
Lecture 466 Marking an Order as Complete 6:17
Lecture 467 Important Info About the Next Lecture - Don't Skip Text
Lecture 468 Don't Cancel Completed Orders! 1:1

Section 22 : Back to the Client

Lecture 469 A Few More Pages 6:15
Lecture 470 Reminder on Data Fetching with Next 6:9
Lecture 471 Two Quick Fixes 5:43
Lecture 472 Scaffolding a Form 3:43
Lecture 473 Sanitizing Price Input 6:29
Lecture 474 Ticket Creation 6:44
Lecture 475 Listing All Tickets 7:41
Lecture 476 Linking to Wildcard Routes 7:7
Lecture 477 Creating an Order 7:25
Lecture 478 Programmatic Navigation to Wildcard Routes 4:16
Lecture 479 The Expiration Timer 10:54
Lecture 480 Displaying the Expiration 1:1
Lecture 481 Showing a Stripe Payment Form 3:6
Lecture 482 Configuring Stripe 4:23
Lecture 483 Test Credit Card Numbers 1:58
Lecture 484 Paying for an Order 9:24
Lecture 485 Filtering Reserved Tickets 2:27
Lecture 486 Header Links 1:47
Lecture 487 Rendering a List of Orders 6:20

Section 23 : CICD

Lecture 488 Development Workflow 3:39
Lecture 489 Git Repository Approaches 6:4
Lecture 490 Creating a GitHub Action 7:11
Lecture 491 Adding a CI Test Script 2:42
Lecture 492 Running Tests on PR Creation 4:48
Lecture 493 Output of Failing Tests 5:48
Lecture 494 Running Tests in Parallel 7:27
Lecture 495 Verifying a Test Run 3:1
Lecture 496 Selective Test Execution 5:44
Lecture 497 Deployment Options 7:40
Lecture 498 Creating a Hosted Cluster 2:38
Lecture 499 Reminder on Kubernetes Context 3:32
Lecture 500 Reminder on Swapping Contexts 3:56