Microservices With Node Js And React (updated 7/2022)

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 Join Our Community!

Lecture 4 What Is a Microservice?

Lecture 5 Data in Microservices

Lecture 6 Big Problems with Data

Lecture 7 Sync Communication Between Services

Lecture 8 Event-Based Communication

Lecture 9 A Crazy Way of Storing Data

Lecture 10 Pros and Cons of Async Communication

Section 2: A Mini-Microservices App

Lecture 11 Important - Optional Boilerplate

Lecture 12 App Overview

Lecture 13 Project Setup

Lecture 14 Posts Service Creation

Lecture 15 Testing the Posts Service

Lecture 16 Implementing a Comments Service

Lecture 17 Quick Comments Test

Lecture 18 Note on the React App

Lecture 19 Suggestion Regarding a Default Export Warning

Lecture 20 React Project Setup

Lecture 21 Building Post Submission

Lecture 22 Handling CORS Errors

Lecture 23 Fetching and Rendering Posts

Lecture 24 Creating Comments

Lecture 25 Displaying Comments

Lecture 26 Completed React App

Lecture 27 Request Minimization Strategies

Lecture 28 An Async Solution

Lecture 29 Common Questions Around Async Events

Lecture 30 Event Bus Overview

Lecture 31 Important Note about Node v15 and Unhandled Promise Rejections

Lecture 32 A Basic Event Bus Implementation

Lecture 33 Emitting Events

Lecture 34 Emitting Comment Creation Events

Lecture 35 Receiving Events

Lecture 36 Creating the Data Query Service

Lecture 37 Parsing Incoming Events

Lecture 38 Using the Query Service

Lecture 39 Adding a Simple Feature

Lecture 40 Issues with Comment Filtering

Lecture 41 A Second Approach

Lecture 42 How to Handle Resource Updates

Lecture 43 Creating the Moderation Service

Lecture 44 Adding Comment Moderation

Lecture 45 Reminder about Node v15 and Error Catching

Lecture 46 Handling Moderation

Lecture 47 Updating Comment Content

Lecture 48 A Quick Test

Lecture 49 Rendering Comments by Status

Lecture 50 Dealing with Missing Events

Lecture 51 Required Node v15+ Update for Query Service

Lecture 52 Implementing Event Sync

Lecture 53 Event Syncing in Action

Section 3: Running Services with Docker

Lecture 54 Deployment Issues

Lecture 55 Why Docker?

Lecture 56 Why Kubernetes?

Lecture 57 Don't Know Docker? Watch This.

Lecture 58 Note About Docker Build Output and Buildkit

Lecture 59 Dockerizing the Posts Service

Lecture 60 Review Some Basic Commands

Lecture 61 Important Note Regarding Node v17

Lecture 62 Dockering Other Services

Section 4: Orchestrating Collections of Services with Kubernetes

Lecture 63 Installing Kubernetes

Lecture 64 IMPORTANT Note for Minikube and MicroK8s Users

Lecture 65 A Kubernetes Tour

Lecture 66 Important Kubernetes Terminology

Lecture 67 Notes on Config Files

Lecture 68 Creating a Pod

Lecture 69 ErrImagePull, ErrImageNeverPull and ImagePullBackoff Errors

Lecture 70 Understanding a Pod Spec

Lecture 71 Common Kubectl Commands

Lecture 72 A Time-Saving Alias

Lecture 73 Introducing Deployments

Lecture 74 Creating a Deployment

Lecture 75 Common Commands Around Deployments

Lecture 76 Updating Deployments

Lecture 77 Preferred Method for Updating Deployments

Lecture 78 Networking With Services

Lecture 79 Creating a NodePort Service

Lecture 80 Accessing NodePort Services

Lecture 81 Setting Up Cluster IP Services

Lecture 82 Building a Deployment for the Event Bus

Lecture 83 Adding ClusterIP Services

Lecture 84 How to Communicate Between Services

Lecture 85 Updating Service Addresses

Lecture 86 Verifying Communication

Lecture 87 Adding Query, Moderation and Comments

Lecture 88 Testing Communication

Lecture 89 Load Balancer Services

Lecture 90 Load Balancers and Ingress

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

Lecture 92 Installing Ingress-Nginx

Lecture 93 Ingress v1 API Required Update

Lecture 94 Writing Ingress Config Files

Lecture 95 Important Note About Port 80

Lecture 96 Hosts File Tweak

Lecture 97 Important Note to Add Environment Variable

Lecture 98 Deploying the React App

Lecture 99 Unique Route Paths

Lecture 100 Final Route Config

Lecture 101 Introducing Skaffold

Lecture 102 Skaffold Setup

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

Lecture 118 Section 5 Checkpoint

Section 6: Leveraging a Cloud Environment for Development

Lecture 119 Note on Remote Development

Lecture 120 Remote Dev with Skaffold

Lecture 121 Free Google Cloud Credits

Lecture 122 Google Cloud Initial Setup

Lecture 123 Kubernetes Cluster Creation

Lecture 124 Kubectl Contexts

Lecture 125 Initializing the GCloud SDK

Lecture 126 Installing the GCloud Context

Lecture 127 Updating the Skaffold Config

Lecture 128 More Skaffold Updates

Lecture 129 Creating a Load Balancer

Lecture 130 Final Config and Test

Section 7: Response Normalization Strategies

Lecture 131 Creating Route Handlers

Lecture 132 Scaffolding Routes

Lecture 133 Adding Validation

Lecture 134 Handling Validation Errors

Lecture 135 Postman HTTPS Issues

Lecture 136 Surprising Complexity Around Errors

Lecture 137 Other Sources of Errors

Lecture 138 Solution for Error Handling

Lecture 139 Building an Error Handling Middleware

Lecture 140 Communicating More Info to the Error Handler

Lecture 141 Encoding More Information In an Error

Lecture 142 Subclassing for Custom Errors

Lecture 143 Determining Error Type

Lecture 144 Converting Errors to Responses

Lecture 145 Moving Logic Into Errors

Lecture 146 Verifying Our Custom Errors

Lecture 147 Final Error Related Code

Lecture 148 How to Define New Custom Errors

Lecture 149 Uh Oh… Async Error Handling

Lecture 150 Section 7 Checkpoint

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

Lecture 167 Section 8 Checkpoint

Section 9: Authentication Strategies and Options

Lecture 168 Fundamental Authentication Strategies

Lecture 169 Huge Issues with Authentication Strategies

Lecture 170 So Which Option?

Lecture 171 Solving Issues with Option #2

Lecture 172 Reminder on Cookies vs JWT's

Lecture 173 Microservices Auth Requirements

Lecture 174 Issues with JWT's and Server Side Rendering

Lecture 175 Cookies and Encryption

Lecture 176 Adding Session Support

Lecture 177 Generating a JWT

Lecture 178 JWT Signing Keys

Lecture 179 Securely Storing Secrets with Kubernetes

Lecture 180 Creating and Accessing Secrets

Lecture 181 Accessing Env Variables in a Pod

Lecture 182 Common Response Properties

Lecture 183 Formatting JSON Properties

Lecture 184 The Signin Flow

Lecture 185 Common Request Validation Middleware

Lecture 186 Sign In Logic

Lecture 187 Quick Sign In Test

Lecture 188 Current User Handler

Lecture 189 Returning the Current User

Lecture 190 Signing Out

Lecture 191 Creating a Current User Middleware

Lecture 192 Augmenting Type Definitions

Lecture 193 Requiring Auth for Route Access

Lecture 194 Section 9 Checkpoint

Section 10: Testing Isolated Microservices

Lecture 195 Scope of Testing

Lecture 196 Testing Goals

Lecture 197 Testing Architecture

Lecture 198 Index to App Refactor

Lecture 199 A Few Dependencies

Lecture 200 Required MongoMemoryServer Updates

Lecture 201 Test Environment Setup

Lecture 202 Our First Test

Lecture 203 An Important Note

Lecture 204 Testing Invalid Input

Lecture 205 Requiring Unique Emails

Lecture 206 Changing Node Env During Tests

Lecture 207 Tests Around Sign In Functionality

Lecture 208 Testing Sign Out

Lecture 209 Issues with Cookies During Testing

Lecture 210 Easy Auth Solution

Lecture 211 globalThis has no index signature TS Error

Lecture 212 Auth Helper Function

Lecture 213 Testing Non-Authed Requests

Lecture 214 Section 10 Checkpoint

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

Lecture 215 Starting the React App

Lecture 216 Reminder on Server Side Rendering

Lecture 217 Suggestion Regarding a Default Export Warning

Lecture 218 Basics of Next JS

Lecture 219 Building a Next Image

Lecture 220 Running Next in Kubernetes

Lecture 221 Note on File Change Detection

Lecture 222 Adding Global CSS

Lecture 223 Adding a Sign Up Form

Lecture 224 Handling Email and Password Inputs

Lecture 225 Successful Account Signup

Lecture 226 Handling Validation Errors

Lecture 227 The useRequest Hook

Lecture 228 Using the useRequest Hook

Lecture 229 An onSuccess Callback

Lecture 230 Overview on Server Side Rendering

Lecture 231 A note about ECONNREFUSED errors

Lecture 232 Fetching Data During SSR

Lecture 233 Why the Error?

Lecture 234 Two Possible Solutions

Lecture 235 Cross Namespace Service Communication

Lecture 236 When is GetInitialProps Called?

Lecture 237 On the Server or the Browser

Lecture 238 Ingress-Nginx Namespace and Service - Important Update

Lecture 239 Specifying the Host

Lecture 240 Passing Through the Cookies

Lecture 241 A Reusable API Client

Lecture 242 Content on the Landing Page

Lecture 243 The Sign In Form

Lecture 244 A Reusable Header

Lecture 245 Moving GetInitialProps

Lecture 246 Issues with Custom App GetInitialProps

Lecture 247 Handling Multiple GetInitialProps

Lecture 248 Passing Props Through

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 globalThis has no index signature TS Error

Lecture 266 Running the Ticket Service

Lecture 267 Mongo Connection URI

Lecture 268 Quick Auth Update

Lecture 269 Test-First Approach

Lecture 270 Creating the Router

Lecture 271 Adding Auth Protection

Lecture 272 Faking Authentication During Tests

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 Streaming Server Notice

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 Remember Mongoose?

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

Lecture 334 Singleton Implementation

Lecture 335 Accessing the NATS Client

Lecture 336 Graceful Shutdown

Lecture 337 Successful Listen!

Lecture 338 Ticket Update Publishing

Lecture 339 Failed Event Publishing

Lecture 340 Handling Publish Failures

Lecture 341 Fixing a Few Tests

Lecture 342 Redirecting Imports

Lecture 343 Providing a Mock Implementation

Lecture 344 Test-Suite Wide Mocks

Lecture 345 Ensuring Mock Invocations

Lecture 346 NATS Env Variables

Section 17: Cross-Service Data Replication In Action

Lecture 347 The Orders Service

Lecture 348 Scaffolding the Orders Service

Lecture 349 A Touch More Setup

Lecture 350 Ingress Routing Rules

Lecture 351 Scaffolding a Few Route Handlers

Lecture 352 Subtle Service Coupling

Lecture 353 Associating Orders and Tickets

Lecture 354 Order Model Setup

Lecture 355 The Need for an Enum

Lecture 356 Creating an Order Status Enum

Lecture 357 More on Mongoose Refs

Lecture 358 Defining the Ticket Model

Lecture 359 Order Creation Logic

Lecture 360 Finding Reserved Tickets

Lecture 361 Convenience Document Methods

Lecture 362 Order Expiration Times

Lecture 363 globalThis has no index signature TS Error

Lecture 364 Test Suite Setup

Lecture 365 Type 'Document' is not assignable Error

Lecture 366 Asserting Tickets Exist

Lecture 367 Asserting Reserved Tickets

Lecture 368 Testing the Success Case

Lecture 369 Fetching a User's Orders

Lecture 370 A Slightly Complicated Test

Lecture 371 Fetching Individual Orders

Lecture 372 Does Fetching Work?

Lecture 373 Cancelling an Order

Lecture 374 Can We Cancel?

Section 18: Understanding Event Flow

Lecture 375 Orders Service Events

Lecture 376 Creating the Events

Lecture 377 Implementing the Publishers

Lecture 378 Publishing the Order Creation

Lecture 379 Publishing Order Cancellation

Lecture 380 Testing Event Publishing

Section 19: Listening for Events and Handling Concurrency Issues

Lecture 381 Time for Listeners!

Lecture 382 Reminder on Listeners

Lecture 383 Blueprint for Listeners

Lecture 384 A Few More Reminders

Lecture 385 Simple onMessage Implementation

Lecture 386 ID Adjustment

Lecture 387 Ticket Updated Listener Implementation

Lecture 388 Initializing the Listeners

Lecture 389 A Quick Manual Test

Lecture 390 Clear Concurrency Issues

Lecture 391 Reminder on Versioning Records

Lecture 392 Optimistic Concurrency Control

Lecture 393 Mongoose Update-If-Current

Lecture 394 Implementing OCC with Mongoose

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

Lecture 396 Testing OCC

Lecture 397 One More Test

Lecture 398 Who Updates Versions?

Lecture 399 Including Versions in Events

Lecture 400 Updating Tickets Event Definitions

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

Lecture 402 Applying a Version Query

Lecture 403 Did it Work?

Lecture 404 Abstracted Query Method

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

Lecture 406 Testing Listeners

Lecture 407 A Complete Listener Test

Lecture 408 Testing the Ack Call

Lecture 409 Testing the Ticket Updated Listener

Lecture 410 Success Case Testing

Lecture 411 Out-Of-Order Events

Lecture 412 The Next Few Videos

Lecture 413 Fixing a Few Tests

Lecture 414 Listeners in the Tickets Service

Lecture 415 Building the Listener

Lecture 416 Strategies for Locking a Ticket

Lecture 417 Reserving a Ticket

Lecture 418 Setup for Testing Reservation

Lecture 419 Test Implementation

Lecture 420 Missing Update Event

Lecture 421 Private vs Protected Properties

Lecture 422 Publishing While Listening

Lecture 423 Mock Function Arguments

Lecture 424 Order Cancelled Listener

Lecture 425 A Lightning-Quick Test

Lecture 426 Don't Forget to Listen!

Lecture 427 Rejecting Edits of Reserved Tickets

Section 20: Worker Services

Lecture 428 The Expiration Service

Lecture 429 Expiration Options

Lecture 430 Initial Setup

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

Lecture 432 A Touch of Kubernetes Setup

Lecture 433 File Sync Setup

Lecture 434 Listener Creation

Lecture 435 What's Bull All About?

Lecture 436 Creating a Queue

Lecture 437 Queueing a Job on Event Arrival

Lecture 438 Testing Job Processing

Lecture 439 Delaying Job Processing

Lecture 440 Defining the Expiration Complete Event

Lecture 441 Publishing an Event on Job Processing

Lecture 442 Handling an Expiration Event

Lecture 443 Emitting the Order Cancelled Event

Lecture 444 Testing the Expiration Complete Listener

Lecture 445 A Touch More Testing

Lecture 446 Listening for Expiration

Section 21: Handling Payments

Lecture 447 The Payments Service

Lecture 448 globalThis has no index signature TS Error

Lecture 449 Initial Setup

Lecture 450 Replicated Fields

Lecture 451 Another Order Model!

Lecture 452 Update-If-Current

Lecture 453 Replicating Orders

Lecture 454 Testing Order Creation

Lecture 455 Marking an Order as Cancelled

Lecture 456 Cancelled Testing

Lecture 457 Starting the Listeners

Lecture 458 Payments Flow with Stripe

Lecture 459 Implementing the Create Charge Handler

Lecture 460 Validating Order Payment

Lecture 461 Testing Order Validation Before Payment

Lecture 462 Testing Same-User Validation

Lecture 463 Stripe Setup

Lecture 464 Creating a Stripe Secret

Lecture 465 Creating a Charge with Stripe

Lecture 466 Manual Testing of Payments

Lecture 467 Automated Payment Testing

Lecture 468 Mocked Stripe Client

Lecture 469 A More Realistic Test Setup

Lecture 470 Realistic Test Implementation

Lecture 471 Tying an Order and Charge Together

Lecture 472 Testing Payment Creation

Lecture 473 Publishing a Payment Created Event

Lecture 474 More on Publishing

Lecture 475 Marking an Order as Complete

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

Lecture 477 Don't Cancel Completed Orders!

Section 22: Back to the Client

Lecture 478 A Few More Pages

Lecture 479 Reminder on Data Fetching with Next

Lecture 480 Two Quick Fixes

Lecture 481 Scaffolding a Form

Lecture 482 Sanitizing Price Input

Lecture 483 Ticket Creation

Lecture 484 Listing All Tickets

Lecture 485 Linking to Wildcard Routes

Lecture 486 Creating an Order

Lecture 487 Programmatic Navigation to Wildcard Routes

Lecture 488 The Expiration Timer

Lecture 489 Displaying the Expiration

Lecture 490 Showing a Stripe Payment Form

Lecture 491 Configuring Stripe

Lecture 492 Test Credit Card Numbers

Lecture 493 Paying for an Order

Lecture 494 Filtering Reserved Tickets

Lecture 495 Header Links

Lecture 496 Rendering a List of Orders

Section 23: CI/CD

Lecture 497 Development Workflow

Lecture 498 Git Repository Approaches

Lecture 499 Creating a GitHub Action

Lecture 500 Adding a CI Test Script

Lecture 501 Running Tests on PR Creation

Lecture 502 Output of Failing Tests

Lecture 503 Running Tests in Parallel

Lecture 504 Verifying a Test Run

Lecture 505 Selective Test Execution

Lecture 506 Deployment Options

Lecture 507 Creating a Hosted Cluster

Lecture 508 Reminder on Kubernetes Context

Lecture 509 Reminder on Swapping Contexts

Lecture 510 The Deployment Plan

Lecture 511 Building an Image in an Action

Lecture 512 Testing the Image Build

Lecture 513 Restarting the Deployment

Lecture 514 Applying Kubernetes Manifests

Lecture 515 Prod vs Dev Manifest Files

Lecture 516 Manual Secret Creation

Lecture 517 Don't Forget Ingress-Nginx!

Lecture 518 Testing Automated Deployment

Lecture 519 Additional Deploy Files

Lecture 520 A Successful Deploy!

Lecture 521 Buying a Domain Name

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

Lecture 523 Configuring the Domain Name

Lecture 524 I Really Hope This Works

Lecture 525 Next Steps

Section 24: [Appendix A] - Basics of Docker

Lecture 526 Why Use Docker?

Lecture 527 What is Docker?

Lecture 528 Docker for Mac / Windows

Lecture 529 Installing Docker on macOS

Lecture 530 Installing Docker with WSL2 on Windows 10 Home and Pro

Lecture 531 Installing Docker for Windows Professional with HyperV

Lecture 532 More Windows Professional Setup with HyperV

Lecture 533 One Last Piece of Windows Professional Setup with HyperV

Lecture 534 Installing Docker on Linux

Lecture 535 Using the Docker Client

Lecture 536 But Really… What's a Container?

Lecture 537 How's Docker Running on Your Computer?

Lecture 538 Docker Run in Detail

Lecture 539 Overriding Default Commands

Lecture 540 Listing Running Containers

Lecture 541 Container Lifecycle

Lecture 542 Restarting Stopped Containers

Lecture 543 Removing Stopped Containers

Lecture 544 Retrieving Output Logs

Lecture 545 Stopping Containers

Lecture 546 Multi-Command Containers

Lecture 547 Executing Commands in Running Containers

Lecture 548 The Purpose of the 'it' Flag

Lecture 549 Getting a Command Prompt in a Container

Lecture 550 Starting with a Shell

Lecture 551 Container Isolation

Lecture 552 Creating Docker Images

Lecture 553 Buildkit for Docker Desktop v2.4.0+ and Edge

Lecture 554 Building a Dockerfile

Lecture 555 Dockerfile Teardown

Lecture 556 What's a Base Image?

Lecture 557 The Build Process in Detail

Lecture 558 A Brief Recap

Lecture 559 Rebuilds with Cache

Lecture 560 Tagging an Image

Lecture 561 Quick Note for Windows Users

Lecture 562 Manual Image Generation with Docker Commit

Lecture 563 Project Outline

Lecture 564 Node Server Setup

Lecture 565 A Few Planned Errors

Lecture 566 Required WORKDIR update - "Could not detect node name", "idealTree" errors

Lecture 567 Base Image Issues

Lecture 568 A Few Missing Files

Lecture 569 Copying Build Files

Lecture 570 Container Port Forwarding

Lecture 571 Specifying a Working Directory

Lecture 572 Unnecessary Rebuilds

Lecture 573 Minimizing Cache Busting and Rebuilds

Section 25: [Appendix B] - Basics of Typescript

Lecture 574 How to Get Help

Lecture 575 TypeScript Overview

Lecture 576 Environment Setup

Lecture 577 A First App

Lecture 578 Executing Typescript Code

Lecture 579 One Quick Change

Lecture 580 Catching Errors with TypeScript

Lecture 581 Catching More Errors!

Lecture 582 Do Not Skip - Course Overview

Lecture 583 Types

Lecture 584 More on Types

Lecture 585 Examples of Types

Lecture 586 Where Do We Use Types?

Lecture 587 Type Annotations and Inference

Lecture 588 Annotations With Variables

Lecture 589 Object Literal Annotations

Lecture 590 Annotations Around Functions

Lecture 591 Understanding Inference

Lecture 592 The Any Type

Lecture 593 Fixing the "Any" Type

Lecture 594 Delayed Initialization

Lecture 595 When Inference Doesn't Work

Lecture 596 More on Annotations Around Functions

Lecture 597 Inference Around Functions

Lecture 598 Annotations for Anonymous Functions

Lecture 599 Void and Never

Lecture 600 Destructuring with Annotations

Lecture 601 Annotations Around Objects

Lecture 602 Arrays in TypeScript

Lecture 603 Why Typed Arrays?

Lecture 604 Multiple Typees in Arrays

Lecture 605 When to Use Typed Arrays

Lecture 606 Tuples in TypeScript

Lecture 607 Tuples in Action

Lecture 608 Why Tuples?

Lecture 609 Interfaces

Lecture 610 Long Type Annotations

Lecture 611 Fixing Annotations With Interfaces

Lecture 612 Syntax Around Interfaces

Lecture 613 Functions in Interfaces

Lecture 614 Code Reuse with Interfaces

Lecture 615 General Plan with Interfaces

Lecture 616 Classes

Lecture 617 Basic Inheritance

Lecture 618 Class Method Modifiers

Lecture 619 Fields in Classes

Lecture 620 Fields with Inheritance

Lecture 621 Where to Use Classes

Lecture 622 App Overview

Lecture 623 Bundling with Parcel

Lecture 624 Project Structure

Lecture 625 IMPORTANT Info About Faker Installation

Lecture 626 Generating Random Data

Lecture 627 Type Definition Files

Lecture 628 Using Type Definition Files

Lecture 629 Export Statements in TypeScript

Lecture 630 Defining a Company

Lecture 631 Important Note About Google Maps Key

Lecture 632 Adding Google Maps Support

Lecture 633 Required Update for New @types Library

Lecture 634 Google Maps Integration with TypeScript

Lecture 635 Exploring Type Definition Files

Lecture 636 Hiding Functionality

Lecture 637 Why Use Private Modifiers? Here's Why

Lecture 638 Adding Markers

Lecture 639 Duplicate Code

Lecture 640 One Possible Solution

Lecture 641 Restricting Access with Interfaces

Lecture 642 Implicit Type Checks

Lecture 643 Showing Popup Windows

Lecture 644 Updating Interface Definitions

Lecture 645 Optional Implements Clauses

Lecture 646 App Wrapup

Section 26: Bonus!

Lecture 647 Bonus!

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