Microservices with Node JS and React

Last updated 8/2023
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 15.59 GB | Duration: 54h 28m

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 jаvascript 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 jаvascript 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 jаvascript 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

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

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

Buy Premium Account From My Download Links & Get Fastest Speed.