Tags
Language
Tags
June 2025
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 1 2 3 4 5
    Attention❗ To save your time, in order to download anything on this site, you must be registered 👉 HERE. If you do not have a registration yet, it is better to do it right away. ✌

    ( • )( • ) ( ͡⚆ ͜ʖ ͡⚆ ) (‿ˠ‿)
    SpicyMags.xyz

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

    Posted By: ELK1nG
    Microservices With Node Js And React (updated 7/2022)

    Microservices With Node Js And React
    Last updated 7/2022
    MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
    Language: English | Size: 15.19 GB | Duration: 54h 30m

    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