Microservices with Node JS and React

Build, deploy, and scale an E-Commerce app using Microservices built with Node, React, Docker and Kubernetes

What you'll learn
Architect large, scalable apps using a collection of microservices
Deploy a multi-service app to the cloud with Docker and Kubernetes
Solve concurrency issues in a distributed systems environment
Leverage your Javascript skills to build a complex web app
Build a Server-Side Rendered React App to render data from your microservices
Understand how enterprise companies design their infrastructure
Share reusable code between multiple Express servers using custom NPM packages
Write comprehensive tests to ensure each service works as designed
Communicate data between services using a lightning-fast event bus
Write nothing but production-level code. No cutting corners!

Requirements
Basic knowledge of Javascript and Express is required
Knowledge of React is good, but not needed
You must be familiar and comfortable with the command line

Description
Event-Based Architecture? Covered! Server side rendering with React? Yep. Scalable, production-ready code? Its here!Microservices are the number one solution for building and scaling out apps that are intended to grow. Just one little issue: there are few resources online that delve into the most complex and nasty issues around them! I built this course to fix that. This course tackles every major issues around microservices head on. From challenges with data replication to confusing unordered event streams, every major challenge of building microservices is covered. Beyond focusing on the basics of microservices, this course is a perfect introduction to the world of full-stack development. You will work all the way from the frontend, assembling a React app using Hooks, to the backend, including database design and deployment strategies. Every step along the way is covered in tremendous detail, with ample diagrams to ensure every step is crystal clear.Many other resources show only the easiest, simplest apps written with microservices. This course does the opposite: we focus on the most challenging aspects of microservices, challenges that you will likely encounter every single day. You will see these difficulties first hand, then solve them with easy-to-understand strategies.-------------------How This Course WorksThis course doesn't focus on using an off-the-shelf microservices framework. Many exist, but they hide the inner workings and challenges of microservices away from you. Instead, we will be using a minimal number of libraries, and write as much custom code as possible. This will expose you to challenging problems and clever solutions when handling subjects like async events!What Technology You'll UseBecause we are building a full stack application, we will use a variety of technologies. On the frontend, we'll use React and Next JS to present content to users. Each service is created using Node and Express. Data for each service is held in either a Mongo database or Redis. The entire app is deployed and runs in Docker containers executed in a Kubernetes cluster. Finally, almost all of the code in this course is written with Typescript.This is a scary list of technologies! Not familiar with some of these? No problem! The course is built assuming that you only know the basics of Javascript and Express. No other knowledge is needed - you will learn everything you need to know.What You'll Be Able to DoBy the time you complete this course, you will be able to:Architect a multi-service applicationDetermine whether your app is a good fit for a microservices approachUnderstand and solve the challenges in async, event-based communication between servicesUse Docker and Kubernetes to deploy a multi-service app to any cloud providerOrganize and enhance the reusability of code in large projectsWhat You'll LearnAn absolute incredible number of topics are covered in this course. Here is a partial list of what you'll do:Practice patterns to create scalable microservices for a variety of app domainsBuild a Server-Side-Rendered React app using Hooks and Next JSWrite a custom implementation of an event busOptionally, run a development environment through a cloud providerGuarantee consistently structured responses from your different API'sSee best practices in communication between different servicesConfigure and scale your services using Kubernetes DeploymentsDocument and enforce structure constraints on events shared across microservicesLimit access to your APIs using JWT-based authenticationAnd much more!This is the course I wish I had when I was learning microservices. A course that focuses on the hardest parts, gives clear explanations, and discusses the pros and cons of different design options. Sign up today and join me in mastering microservices!

Overview
Section 1: Fundamental Ideas Around Microservices

Lecture 1 How to Get Help

Lecture 2 Course Resources

Lecture 3 What Is a Microservice?

Lecture 4 Data in Microservices

Lecture 5 Big Problems with Data

Lecture 6 Sync Communication Between Services

Lecture 7 Event-Based Communication

Lecture 8 A Crazy Way of Storing Data

Lecture 9 Pros and Cons of Async Communication

Section 2: A Mini-Microservices App

Lecture 10 Important - Optional Boilerplate

Lecture 11 App Overview

Lecture 12 Project Setup

Lecture 13 Posts Service Creation

Lecture 14 Testing the Posts Service

Lecture 15 Implementing a Comments Service

Lecture 16 Quick Comments Test

Lecture 17 Note on the React App

Lecture 18 Addressing Default Export and ReactDom.render Warnings

Lecture 19 React Project Setup

Lecture 20 Building Post Submission

Lecture 21 Handling CORS Errors

Lecture 22 Fetching and Rendering Posts

Lecture 23 Creating Comments

Lecture 24 Displaying Comments

Lecture 25 Completed React App

Lecture 26 Request Minimization Strategies

Lecture 27 An Async Solution

Lecture 28 Common Questions Around Async Events

Lecture 29 Event Bus Overview

Lecture 30 Important Note about Node v15 and Unhandled Promise Rejections

Lecture 31 A Basic Event Bus Implementation

Lecture 32 Emitting Events

Lecture 33 Emitting Comment Creation Events

Lecture 34 Receiving Events

Lecture 35 Creating the Data Query Service

Lecture 36 Parsing Incoming Events

Lecture 37 Using the Query Service

Lecture 38 Adding a Simple Feature

Lecture 39 Issues with Comment Filtering

Lecture 40 A Second Approach

Lecture 41 How to Handle Resource Updates

Lecture 42 Creating the Moderation Service

Lecture 43 Adding Comment Moderation

Lecture 44 Reminder about Node v15 and Error Catching

Lecture 45 Handling Moderation

Lecture 46 Updating Comment Content

Lecture 47 A Quick Test

Lecture 48 Rendering Comments by Status

Lecture 49 Dealing with Missing Events

Lecture 50 Required Node v15+ Update for Query Service

Lecture 51 Implementing Event Sync

Lecture 52 Event Syncing in Action

Section 3: Running Services with Docker

Lecture 53 Deployment Issues

Lecture 54 Why Docker?

Lecture 55 Why Kubernetes?

Lecture 56 Don't Know Docker? Watch This.

Lecture 57 Note About Docker Build Output and Buildkit

Lecture 58 Dockerizing the Posts Service

Lecture 59 Review Some Basic Commands

Lecture 60 Dockering Other Services

Section 4: Orchestrating Collections of Services with Kubernetes

Lecture 61 Warning on Docker Desktop for Linux

Lecture 62 Installing Kubernetes

Lecture 63 IMPORTANT Note for Minikube and MicroK8s Users

Lecture 64 A Kubernetes Tour

Lecture 65 Important Kubernetes Terminology

Lecture 66 Notes on Config Files

Lecture 67 Creating a Pod

Lecture 68 ErrImagePull, ErrImageNeverPull and ImagePullBackoff Errors

Lecture 69 Understanding a Pod Spec

Lecture 70 Common Kubectl Commands

Lecture 71 A Time-Saving Alias

Lecture 72 Introducing Deployments

Lecture 73 Creating a Deployment

Lecture 74 Common Commands Around Deployments

Lecture 75 Updating Deployments

Lecture 76 Preferred Method for Updating Deployments

Lecture 77 Networking With Services

Lecture 78 Creating a NodePort Service

Lecture 79 Accessing NodePort Services

Lecture 80 Setting Up Cluster IP Services

Lecture 81 Building a Deployment for the Event Bus

Lecture 82 Adding ClusterIP Services

Lecture 83 How to Communicate Between Services

Lecture 84 Updating Service Addresses

Lecture 85 Verifying Communication

Lecture 86 Adding Query, Moderation and Comments

Lecture 87 Testing Communication

Lecture 88 Load Balancer Services

Lecture 89 Load Balancers and Ingress

Lecture 90 Important - DO NOT SKIP - Ingress Nginx Installation Info

Lecture 91 Installing Ingress-Nginx

Lecture 92 Ingress v1 API Required Update + pathType Warning

Lecture 93 Writing Ingress Config Files

Lecture 94 Important Note About Port 80

Lecture 95 Hosts File Tweak

Lecture 96 Important Note to Add Environment Variable

Lecture 97 Deploying the React App

Lecture 98 Unique Route Paths

Lecture 99 Final Route Config

Lecture 100 Introducing Skaffold

Lecture 101 Skaffold Setup

Lecture 102 Skaffold API version Update

Lecture 103 First Time Skaffold Startup

Lecture 104 A Few Notes on Skaffold

Section 5: Architecture of Multi-Service Apps

Lecture 105 Big Ticket Items

Lecture 106 App Overview

Lecture 107 Resource Types

Lecture 108 Service Types

Lecture 109 Events and Architecture Design

Lecture 110 Note on Typescript

Lecture 111 Auth Service Setup

Lecture 112 Auth K8s Setup

Lecture 113 Adding Skaffold

Lecture 114 Note on Code Reloading

Lecture 115 Ingress v1 API Required Update

Lecture 116 Ingress-Nginx Setup

Lecture 117 Hosts File and Security Warning

Section 6: Leveraging a Cloud Environment for Development

Lecture 118 Note on Remote Development

Lecture 119 Remote Dev with Skaffold

Lecture 120 Free Google Cloud Credits

Lecture 121 Google Cloud Initial Setup

Lecture 122 Kubernetes Cluster Creation

Lecture 123 Kubectl Contexts

Lecture 124 Initializing the GCloud SDK

Lecture 125 Installing the GCloud Context

Lecture 126 Updating the Skaffold Config

Lecture 127 More Skaffold Updates

Lecture 128 Creating a Load Balancer

Lecture 129 Final Config and Test

Section 7: Response Normalization Strategies

Lecture 130 Creating Route Handlers

Lecture 131 Scaffolding Routes

Lecture 132 Adding Validation

Lecture 133 Handling Validation Errors

Lecture 134 Postman HTTPS Issues

Lecture 135 Surprising Complexity Around Errors

Lecture 136 Other Sources of Errors

Lecture 137 Solution for Error Handling

Lecture 138 Building an Error Handling Middleware

Lecture 139 Communicating More Info to the Error Handler

Lecture 140 Encoding More Information In an Error

Lecture 141 Subclassing for Custom Errors

Lecture 142 Determining Error Type

Lecture 143 Property 'param' does not exist on type 'AlternativeValidationError'

Lecture 144 Converting Errors to Responses

Lecture 145 Moving Logic Into Errors

Lecture 146 serializeErrors' not assignable to the same property in base type 'CustomError'

Lecture 147 Verifying Our Custom Errors

Lecture 148 Final Error Related Code

Lecture 149 How to Define New Custom Errors

Lecture 150 Uh Oh... Async Error Handling

Section 8: Database Management and Modeling

Lecture 151 Creating Databases in Kubernetes

Lecture 152 Connecting to MongoDB

Lecture 153 Understanding the Signup Flow

Lecture 154 Getting TypeScript and Mongoose to Cooperate

Lecture 155 Creating the User Model

Lecture 156 Type Checking User Properties

Lecture 157 Adding Static Properties to a Model

Lecture 158 Defining Extra Document Properties

Lecture 159 What's That Angle Bracket For?

Lecture 160 User Creation

Lecture 161 Proper Error Handling

Lecture 162 Note on Password Hashing

Lecture 163 Reminder on Password Hashing

Lecture 164 Adding Password Hashing

Lecture 165 Comparing Hashed Password

Lecture 166 Mongoose Pre-Save Hooks

Section 9: Authentication Strategies and Options

Lecture 167 Fundamental Authentication Strategies

Lecture 168 Huge Issues with Authentication Strategies

Lecture 169 So Which Option?

Lecture 170 Solving Issues with Option #2

Lecture 171 Reminder on Cookies vs JWT's

Lecture 172 Microservices Auth Requirements

Lecture 173 Issues with JWT's and Server Side Rendering

Lecture 174 Cookies and Encryption

Lecture 175 Adding Session Support

Lecture 176 Generating a JWT

Lecture 177 JWT Signing Keys

Lecture 178 Securely Storing Secrets with Kubernetes

Lecture 179 Creating and Accessing Secrets

Lecture 180 Accessing Env Variables in a Pod

Lecture 181 Common Response Properties

Lecture 182 Formatting JSON Properties

Lecture 183 The Signin Flow

Lecture 184 Common Request Validation Middleware

Lecture 185 Sign In Logic

Lecture 186 Quick Sign In Test

Lecture 187 Current User Handler

Lecture 188 Returning the Current User

Lecture 189 Signing Out

Lecture 190 Creating a Current User Middleware

Lecture 191 Augmenting Type Definitions

Lecture 192 Requiring Auth for Route Access

Section 10: Testing Isolated Microservices

Lecture 193 Scope of Testing

Lecture 194 Testing Goals

Lecture 195 Testing Architecture

Lecture 196 Index to App Refactor

Lecture 197 Replacing --only=prod Install Flag

Lecture 198 A Few Dependencies

Lecture 199 Required MongoMemoryServer Updates

Lecture 200 Test Environment Setup

Lecture 201 Our First Test

Lecture 202 An Important Note

Lecture 203 Testing Invalid Input

Lecture 204 Requiring Unique Emails

Lecture 205 Changing Node Env During Tests

Lecture 206 Tests Around Sign In Functionality

Lecture 207 Testing Sign Out

Lecture 208 Issues with Cookies During Testing

Lecture 209 Easy Auth Solution

Lecture 210 globalThis has no index signature TS Error

Lecture 211 Auth Helper Function

Lecture 212 Testing Non-Authed Requests

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

Lecture 213 Starting the React App

Lecture 214 Reminder on Server Side Rendering

Lecture 215 Suggestion Regarding a Default Export Warning

Lecture 216 Basics of Next JS

Lecture 217 Building a Next Image

Lecture 218 Running Next in Kubernetes

Lecture 219 Small Update for Custom Webpack Config

Lecture 220 Note on File Change Detection

Lecture 221 Adding Global CSS

Lecture 222 Adding a Sign Up Form

Lecture 223 Handling Email and Password Inputs

Lecture 224 Successful Account Signup

Lecture 225 Handling Validation Errors

Lecture 226 The useRequest Hook

Lecture 227 Using the useRequest Hook

Lecture 228 An onSuccess Callback

Lecture 229 Overview on Server Side Rendering

Lecture 230 A note about ECONNREFUSED errors

Lecture 231 Fetching Data During SSR

Lecture 232 Why the Error?

Lecture 233 Two Possible Solutions

Lecture 234 Cross Namespace Service Communication

Lecture 235 When is GetInitialProps Called?

Lecture 236 On the Server or the Browser

Lecture 237 Ingress-Nginx Namespace and Service - Important Update

Lecture 238 Specifying the Host

Lecture 239 Passing Through the Cookies

Lecture 240 A Reusable API Client

Lecture 241 Content on the Landing Page

Lecture 242 The Sign In Form

Lecture 243 A Reusable Header

Lecture 244 Moving GetInitialProps

Lecture 245 Issues with Custom App GetInitialProps

Lecture 246 Handling Multiple GetInitialProps

Lecture 247 Passing Props Through

Lecture 248 Error: Invalid with child

Lecture 249 Building the Header

Lecture 250 Conditionally Showing Links

Lecture 251 Signing Out

Lecture 252 React App Catchup & Checkpoint

Section 12: Code Sharing and Reuse Between Services

Lecture 253 Shared Logic Between Services

Lecture 254 Options for Code Sharing

Lecture 255 NPM Organizations

Lecture 256 Publishing NPM Modules

Lecture 257 Project Setup

Lecture 258 Typo in package.json "files" Field - Do Not Skip

Lecture 259 An Easy Publish Command

Lecture 260 Relocating Shared Code

Lecture 261 Updating Import Statements

Lecture 262 Updating the Common Module

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

Lecture 263 Ticketing Service Overview

Lecture 264 Project Setup

Lecture 265 Running the Ticket Service

Lecture 266 Mongo Connection URI

Lecture 267 Quick Auth Update

Lecture 268 Test-First Approach

Lecture 269 Creating the Router

Lecture 270 Adding Auth Protection

Lecture 271 Faking Authentication During Tests

Lecture 272 A Required Session Fix and a Global Signin Reminder

Lecture 273 Building a Session

Lecture 274 Testing Request Validation

Lecture 275 Validating Title and Price

Lecture 276 Reminder on Mongoose with TypeScript

Lecture 277 Defining the Ticket Model

Lecture 278 Creation via Route Handler

Lecture 279 Testing Show Routes

Lecture 280 Unexpected Failure!

Lecture 281 What's that Error?!

Lecture 282 Better Error Logging

Lecture 283 Complete Index Route Implementation

Lecture 284 Ticket Updating

Lecture 285 Handling Updates

Lecture 286 Permission Checking

Lecture 287 Final Update Changes

Lecture 288 Manual Testing

Section 14: NATS Streaming Server - An Event Bus Implementation

Lecture 289 What Now?

Lecture 290 NATS Server Status - IMPORTANT NOTE

Lecture 291 Three Important Items

Lecture 292 Creating a NATS Streaming Deployment

Lecture 293 Big Notes on NATS Streaming

Lecture 294 Building a NATS Test Project

Lecture 295 Port-Forwarding with Kubectl

Lecture 296 Publishing Events

Lecture 297 Small Required Command Change

Lecture 298 Listening For Data

Lecture 299 Accessing Event Data

Lecture 300 Client ID Generation

Lecture 301 Queue Groups

Lecture 302 Manual Ack Mode

Lecture 303 Client Health Checks

Lecture 304 Graceful Client Shutdown

Lecture 305 Core Concurrency Issues

Lecture 306 Common Questions

Lecture 307 [Optional] More Possible Concurrency Solutions

Lecture 308 Solving Concurrency Issues

Lecture 309 Concurrency Control with the Tickets App

Lecture 310 Event Redelivery

Lecture 311 Durable Subscriptions

Section 15: Connecting to NATS in a Node JS World

Lecture 312 Reusable NATS Listeners

Lecture 313 The Listener Abstract Class

Lecture 314 Extending the Listener

Lecture 315 Quick Refactor

Lecture 316 Leveraging TypeScript for Listener Validation

Lecture 317 Subjects Enum

Lecture 318 Custom Event Interface

Lecture 319 Enforcing Listener Subjects

Lecture 320 Quick Note: 'readonly' in Typescript

Lecture 321 Enforcing Data Types

Lecture 322 Where Does this Get Used?

Lecture 323 Custom Publisher

Lecture 324 Using the Custom Publisher

Lecture 325 Awaiting Event Publication

Lecture 326 Common Event Definitions Summary

Lecture 327 Updating the Common Module

Lecture 328 Restarting NATS

Section 16: Managing a NATS Client

Lecture 329 Publishing Ticket Creation

Lecture 330 More on Publishing

Lecture 331 NATS Client Singleton

Lecture 332 Node Nats Streaming Installation

Lecture 333 Remember Mongoose?

Lecture 334 TS Error - Did you forget to include 'void' in your type argument

Lecture 335 Singleton Implementation

Lecture 336 Accessing the NATS Client

Lecture 337 Graceful Shutdown

Lecture 338 Successful Listen!

Lecture 339 Ticket Update Publishing

Lecture 340 Failed Event Publishing

Lecture 341 Handling Publish Failures

Lecture 342 Fixing a Few Tests

Lecture 343 Redirecting Imports

Lecture 344 Providing a Mock Implementation

Lecture 345 Test-Suite Wide Mocks

Lecture 346 Ensuring Mock Invocations

Lecture 347 NATS Env Variables

Section 17: Cross-Service Data Replication In Action

Lecture 348 The Orders Service

Lecture 349 Scaffolding the Orders Service

Lecture 350 A Touch More Setup

Lecture 351 Ingress Routing Rules

Lecture 352 Scaffolding a Few Route Handlers

Lecture 353 Subtle Service Coupling

Lecture 354 Associating Orders and Tickets

Lecture 355 Order Model Setup

Lecture 356 The Need for an Enum

Lecture 357 Creating an Order Status Enum

Lecture 358 More on Mongoose Refs

Lecture 359 Defining the Ticket Model

Lecture 360 Order Creation Logic

Lecture 361 Finding Reserved Tickets

Lecture 362 Convenience Document Methods

Lecture 363 Order Expiration Times

Lecture 364 globalThis has no index signature TS Error

Lecture 365 Test Suite Setup

Lecture 366 Small Update for "Value of type 'typeof ObjectId' is not callable"

Lecture 367 Asserting Tickets Exist

Lecture 368 Asserting Reserved Tickets

Lecture 369 Testing the Success Case

Lecture 370 Fetching a User's Orders

Lecture 371 A Slightly Complicated Test

Lecture 372 Fetching Individual Orders

Lecture 373 Does Fetching Work?

Lecture 374 Cancelling an Order

Lecture 375 Can We Cancel?

Section 18: Understanding Event Flow

Lecture 376 Orders Service Events

Lecture 377 Creating the Events

Lecture 378 Implementing the Publishers

Lecture 379 Publishing the Order Creation

Lecture 380 Publishing Order Cancellation

Lecture 381 Testing Event Publishing

Section 19: Listening for Events and Handling Concurrency Issues

Lecture 382 Heads Up Regarding Some Mongoose TS Errors

Lecture 383 Time for Listeners!

Lecture 384 Reminder on Listeners

Lecture 385 Blueprint for Listeners

Lecture 386 A Few More Reminders

Lecture 387 Simple onMessage Implementation

Lecture 388 ID Adjustment

Lecture 389 Ticket Updated Listener Implementation

Lecture 390 Initializing the Listeners

Lecture 391 A Quick Manual Test

Lecture 392 Clear Concurrency Issues

Lecture 393 Reminder on Versioning Records

Lecture 394 Optimistic Concurrency Control

Lecture 395 Mongoose Update-If-Current

Lecture 396 Implementing OCC with Mongoose

Lecture 397 Test functions cannot both take a 'done' callback and return something Error

Lecture 398 Testing OCC

Lecture 399 One More Test

Lecture 400 Who Updates Versions?

Lecture 401 Including Versions in Events

Lecture 402 Updating Tickets Event Definitions

Lecture 403 Property 'version' is missing TS Errors After Running Skaffold

Lecture 404 Applying a Version Query

Lecture 405 Did it Work?

Lecture 406 Abstracted Query Method

Lecture 407 [Optional] Versioning Without Update-If-Current

Lecture 408 Testing Listeners

Lecture 409 A Complete Listener Test

Lecture 410 Testing the Ack Call

Lecture 411 Testing the Ticket Updated Listener

Lecture 412 Success Case Testing

Lecture 413 Out-Of-Order Events

Lecture 414 The Next Few Videos

Lecture 415 Fixing a Few Tests

Lecture 416 Listeners in the Tickets Service

Lecture 417 Building the Listener

Lecture 418 Strategies for Locking a Ticket

Lecture 419 Reserving a Ticket

Lecture 420 Setup for Testing Reservation

Lecture 421 Test Implementation

Lecture 422 Missing Update Event

Lecture 423 Private vs Protected Properties

Lecture 424 Publishing While Listening

Lecture 425 Mock Function Arguments

Lecture 426 Order Cancelled Listener

Lecture 427 A Lightning-Quick Test

Lecture 428 Don't Forget to Listen!

Lecture 429 Rejecting Edits of Reserved Tickets

Section 20: Worker Services

Lecture 430 The Expiration Service

Lecture 431 Expiration Options

Lecture 432 Initial Setup

Lecture 433 Skaffold errors - Expiration Image Can't be Pulled

Lecture 434 A Touch of Kubernetes Setup

Lecture 435 File Sync Setup

Lecture 436 Listener Creation

Lecture 437 What's Bull All About?

Lecture 438 Creating a Queue

Lecture 439 Queueing a Job on Event Arrival

Lecture 440 Testing Job Processing

Lecture 441 Delaying Job Processing

Lecture 442 Defining the Expiration Complete Event

Lecture 443 Publishing an Event on Job Processing

Lecture 444 Handling an Expiration Event

Lecture 445 Emitting the Order Cancelled Event

Lecture 446 Testing the Expiration Complete Listener

Lecture 447 A Touch More Testing

Lecture 448 Listening for Expiration

Section 21: Handling Payments

Lecture 449 The Payments Service

Lecture 450 globalThis has no index signature TS Error

Lecture 451 Initial Setup

Lecture 452 Replicated Fields

Lecture 453 Another Order Model!

Lecture 454 Update-If-Current

Lecture 455 Replicating Orders

Lecture 456 Testing Order Creation

Lecture 457 Marking an Order as Cancelled

Lecture 458 Cancelled Testing

Lecture 459 Starting the Listeners

Lecture 460 Payments Flow with Stripe

Lecture 461 Implementing the Create Charge Handler

Lecture 462 Validating Order Payment

Lecture 463 Testing Order Validation Before Payment

Lecture 464 Testing Same-User Validation

Lecture 465 Stripe Setup

Lecture 466 Creating a Stripe Secret

Lecture 467 Creating a Charge with Stripe

Lecture 468 Manual Testing of Payments

Lecture 469 Automated Payment Testing

Lecture 470 Mocked Stripe Client

Lecture 471 A More Realistic Test Setup

Lecture 472 Realistic Test Implementation

Lecture 473 Tying an Order and Charge Together

Lecture 474 Testing Payment Creation

Lecture 475 Publishing a Payment Created Event

Lecture 476 More on Publishing

Lecture 477 Marking an Order as Complete

Lecture 478 Important Info About the Next Lecture - Don't Skip

Lecture 479 Don't Cancel Completed Orders!

Section 22: Back to the Client

Lecture 480 A Few More Pages

Lecture 481 Reminder on Data Fetching with Next

Lecture 482 Two Quick Fixes

Lecture 483 Scaffolding a Form

Lecture 484 Sanitizing Price Input

Lecture 485 Ticket Creation

Lecture 486 Listing All Tickets

Lecture 487 Reminder on Invalid with child Errors

Lecture 488 Linking to Wildcard Routes

Lecture 489 Creating an Order

Lecture 490 Programmatic Navigation to Wildcard Routes

Lecture 491 The Expiration Timer

Lecture 492 Displaying the Expiration

Lecture 493 Showing a Stripe Payment Form

Lecture 494 Module not found: Can't resolve 'prop-types'

Lecture 495 Configuring Stripe

Lecture 496 Test Credit Card Numbers

Lecture 497 Paying for an Order

Lecture 498 Filtering Reserved Tickets

Lecture 499 Header Links

Lecture 500 Rendering a List of Orders

Section 23: CI/CD

Lecture 501 Development Workflow

Lecture 502 Git Repository Approaches

Lecture 503 Creating a GitHub Action

Lecture 504 Adding a CI Test Script

Lecture 505 Tests in GitHub Actions Hang - Jest did not exit

Lecture 506 Running Tests on PR Creation

Lecture 507 Output of Failing Tests

Lecture 508 Running Tests in Parallel

Lecture 509 Verifying a Test Run

Lecture 510 Selective Test Execution

Lecture 511 Deployment Options

Lecture 512 Creating a Hosted Cluster

Lecture 513 Reminder on Kubernetes Context

Lecture 514 Reminder on Swapping Contexts

Lecture 515 The Deployment Plan

Lecture 516 Building an Image in an Action

Lecture 517 Testing the Image Build

Lecture 518 Restarting the Deployment

Lecture 519 Applying Kubernetes Manifests

Lecture 520 Prod vs Dev Manifest Files

Lecture 521 Manual Secret Creation

Lecture 522 Don't Forget Ingress-Nginx!

Lecture 523 Testing Automated Deployment

Lecture 524 Additional Deploy Files

Lecture 525 A Successful Deploy!

Lecture 526 Buying a Domain Name

Lecture 527 Three Important Changes Needed to Deploy - Do Not Skip!

Lecture 528 Configuring the Domain Name

Lecture 529 I Really Hope This Works

Lecture 530 Next Steps

Section 24: [Appendix A] - Basics of Docker

Lecture 531 Finished Code and Diagrams

Lecture 532 Why Use Docker?

Lecture 533 What is Docker?

Lecture 534 Docker for Mac / Windows

Lecture 535 Installing Docker on macOS

Lecture 536 Installing Docker with WSL2 on Windows 10/11

Lecture 537 Installing Docker on Linux

Lecture 538 Using the Docker Client

Lecture 539 But Really... What's a Container?

Lecture 540 How's Docker Running on Your Computer?

Lecture 541 Docker Run in Detail

Lecture 542 Overriding Default Commands

Lecture 543 Listing Running Containers

Lecture 544 Container Lifecycle

Lecture 545 Restarting Stopped Containers

Lecture 546 Removing Stopped Containers

Lecture 547 Retrieving Output Logs

Lecture 548 Stopping Containers

Lecture 549 Multi-Command Containers

Lecture 550 Executing Commands in Running Containers

Lecture 551 The Purpose of the 'it' Flag

Lecture 552 Getting a Command Prompt in a Container

Lecture 553 Starting with a Shell

Lecture 554 Container Isolation

Lecture 555 Creating Docker Images

Lecture 556 Buildkit for Docker Desktop

Lecture 557 Building a Dockerfile

Lecture 558 Dockerfile Teardown

Lecture 559 What's a Base Image?

Lecture 560 The Build Process in Detail

Lecture 561 A Brief Recap

Lecture 562 Rebuilds with Cache

Lecture 563 Tagging an Image

Lecture 564 Quick Note for Windows Users

Lecture 565 Manual Image Generation with Docker Commit

Lecture 566 Project Outline

Lecture 567 Node Server Setup

Lecture 568 A Few Planned Errors

Lecture 569 Required Node Base Image Version

Lecture 570 Base Image Issues

Lecture 571 A Few Missing Files

Lecture 572 Copying Build Files

Lecture 573 Container Port Forwarding

Lecture 574 Specifying a Working Directory

Lecture 575 Unnecessary Rebuilds

Lecture 576 Minimizing Cache Busting and Rebuilds

Section 25: [Appendix B] - Basics of Typescript

Lecture 577 How to Get Help

Lecture 578 TypeScript Overview

Lecture 579 Environment Setup

Lecture 580 Important Axios Version Information

Lecture 581 A First App

Lecture 582 Executing Typescript Code

Lecture 583 One Quick Change

Lecture 584 Catching Errors with TypeScript

Lecture 585 Catching More Errors!

Lecture 586 Do Not Skip - Course Overview

Lecture 587 Types

Lecture 588 More on Types

Lecture 589 Examples of Types

Lecture 590 Where Do We Use Types?

Lecture 591 Type Annotations and Inference

Lecture 592 Annotations With Variables

Lecture 593 Object Literal Annotations

Lecture 594 Annotations Around Functions

Lecture 595 Understanding Inference

Lecture 596 The Any Type

Lecture 597 Fixing the "Any" Type

Lecture 598 Delayed Initialization

Lecture 599 When Inference Doesn't Work

Lecture 600 More on Annotations Around Functions

Lecture 601 Inference Around Functions

Lecture 602 Annotations for Anonymous Functions

Lecture 603 Void and Never

Lecture 604 Destructuring with Annotations

Lecture 605 Annotations Around Objects

Lecture 606 Arrays in TypeScript

Lecture 607 Why Typed Arrays?

Lecture 608 Multiple Typees in Arrays

Lecture 609 When to Use Typed Arrays

Lecture 610 Tuples in TypeScript

Lecture 611 Tuples in Action

Lecture 612 Why Tuples?

Lecture 613 Interfaces

Lecture 614 Long Type Annotations

Lecture 615 Fixing Annotations With Interfaces

Lecture 616 Syntax Around Interfaces

Lecture 617 Functions in Interfaces

Lecture 618 Code Reuse with Interfaces

Lecture 619 General Plan with Interfaces

Lecture 620 Classes

Lecture 621 Basic Inheritance

Lecture 622 Class Method Modifiers

Lecture 623 Fields in Classes

Lecture 624 Fields with Inheritance

Lecture 625 Where to Use Classes

Lecture 626 Updated Parcel Instructions

Lecture 627 App Overview

Lecture 628 Bundling with Parcel

Lecture 629 Project Structure

Lecture 630 IMPORTANT Info About Faker Installation

Lecture 631 Generating Random Data

Lecture 632 Type Definition Files

Lecture 633 Using Type Definition Files

Lecture 634 Export Statements in TypeScript

Lecture 635 Defining a Company

Lecture 636 Important Note About Google Maps Key

Lecture 637 Adding Google Maps Support

Lecture 638 Required Update for New @types Library

Lecture 639 Google Maps Integration with TypeScript

Lecture 640 Exploring Type Definition Files

Lecture 641 Hiding Functionality

Lecture 642 Why Use Private Modifiers? Here's Why

Lecture 643 Adding Markers

Lecture 644 Duplicate Code

Lecture 645 One Possible Solution

Lecture 646 Restricting Access with Interfaces

Lecture 647 Implicit Type Checks

Lecture 648 Showing Popup Windows

Lecture 649 Updating Interface Definitions

Lecture 650 Optional Implements Clauses

Lecture 651 App Wrapup

Section 26: Bonus!

Lecture 652 Bonus!

Javascript engineers looking to build large, scalable applications,This course is *not* designed for sysadmins focused on infrastructure deployment

without You and Your Support We Can’t Continue
Thanks for Buying Premium From My Links for Support
Click >>here & Visit My Blog Daily for More Udemy Tutorial. If You Need Update or Links Dead Don't Wait Just Pm Me or Leave Comment at This Post