Microservices with Node JS and React
4.8 (1,170 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
12,014 students enrolled

Microservices with Node JS and React

Build, deploy, and scale an E-Commerce app using Microservices built with Node, React, Docker and Kubernetes
Bestseller
4.8 (1,170 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
12,014 students enrolled
Created by Stephen Grider
Last updated 5/2020
English
English [Auto-generated]
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 54 hours on-demand video
  • 11 articles
  • 268 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
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!
Course content
Expand all 601 lectures 54:07:10
+ Fundamental Ideas Around Microservices
8 lectures 45:12
Data in Microservices
07:34
Quiz - Data in Microservices
3 questions
Big Problems with Data
05:08
Sync Communication Between Services
06:53
Event-Based Communication
05:19
A Crazy Way of Storing Data
09:48
Pros and Cons of Async Communication
06:15
+ A Mini-Microservices App
38 lectures 03:32:51
App Overview
05:44
Project Setup
04:57
Posts Service Creation
08:18
Testing the Posts Service
04:04
Implementing a Comments Service
08:22
Quick Comments Test
03:57
Note on the React App
00:20
React Project Setup
05:00
Building Post Submission
09:54
Handling CORS Errors
04:08
Fetching and Rendering Posts
10:04
Creating Comments
08:09
Displaying Comments
07:23
Completed React App
00:12
Request Minimization Strategies
04:54
An Async Solution
07:16
Common Questions Around Async Events
04:14
Event Bus Overview
05:14
A Basic Event Bus Implementation
05:22
Emitting Events
05:18
Emitting Comment Creation Events
03:45
Receiving Events
04:33
Creating the Data Query Service
04:42
Parsing Incoming Events
07:02
Using the Query Service
07:09
Adding a Simple Feature
04:46
Issues with Comment Filtering
07:43
A Second Approach
05:37
How to Handle Resource Updates
04:45
Creating the Moderation Service
04:52
Adding Comment Moderation
04:26
Handling Moderation
05:29
Updating Comment Content
04:58
A Quick Test
05:57
Rendering Comments by Status
03:26
Dealing with Missing Events
10:23
Implementing Event Sync
06:11
Event Syncing in Action
04:16
+ Running Services with Docker
7 lectures 29:20
Deployment Issues
06:55
Why Docker?
02:55
Why Kubernetes?
05:47
Don't Know Docker? Watch This.
01:17
Dockerizing the Posts Service
04:02
Review Some Basic Commands
05:23
Dockering Other Services
03:01
+ Orchestrating Collections of Services with Kubernetes
37 lectures 03:19:27
Installing Kubernetes
03:19
A Kubernetes Tour
09:45
Important Kubernetes Terminology
02:51
Notes on Config Files
03:11
Creating a Pod
06:41
Understanding a Pod Spec
05:15
Common Kubectl Commands
04:44
A Time-Saving Alias
02:26
Introducing Deployments
03:27
Creating a Deployment
06:11
Common Commands Around Deployments
04:35
Updating Deployments
06:02
Preferred Method for Updating Deployments
05:42
Networking With Services
04:15
Creating a NodePort Service
07:52
Accessing NodePort Services
05:09
Setting Up Cluster IP Services
03:12
Building a Deployment for the Event Bus
05:35
Adding ClusterIP Services
07:37
How to Communicate Between Services
04:09
Updating Service Addresses
06:27
Verifying Communication
05:00
Adding Query, Moderation and Comments
09:57
Testing Communication
05:29
Load Balancer Services
05:13
Load Balancers and Ingress
06:38
Installing Ingress-Nginx
07:40
Writing Ingress Config Files
04:47
Hosts File Tweak
06:15
Quick Note
00:32
Deploying the React App
06:09
Unique Route Paths
06:55
Final Route Config
06:32
Introducing Skaffold
03:08
Skaffold Setup
09:17
First Time Skaffold Startup
01:00
A Few Notes on Skaffold
06:30
+ Architecture of Multi-Service Apps
12 lectures 01:05:27
Big Ticket Items
15:11
App Overview
08:53
Resource Types
03:23
Service Types
03:37
Events and Architecture Design
03:48
Note on Typescript
00:20
Auth Service Setup
04:51
Auth K8s Setup
08:15
Adding Skaffold
05:36
Note on Code Reloading
00:08
Ingress-Nginx Setup
07:19
Hosts File and Security Warning
04:06
+ Leveraging a Cloud Environment for Development
11 lectures 46:34
Note on Remote Development
02:51
Remote Dev with Skaffold
06:35
Google Cloud Initial Setup
02:43
Kubernetes Cluster Creation
03:59
Kubectl Contexts
03:49
Initializing the GCloud SDK
05:03
Installing the GCloud Context
04:17
Updating the Skaffold Config
04:34
More Skaffold Updates
01:06
Creating a Load Balancer
05:12
Final Config and Test
06:25
+ Response Normalization Strategies
19 lectures 01:57:39
Creating Route Handlers
05:40
Scaffolding Routes
04:05
Adding Validation
08:38
Handling Validation Errors
06:18
Postman HTTPS Issues
00:11
Surprising Complexity Around Errors
06:06
Other Sources of Errors
04:17
Solution for Error Handling
04:50
Building an Error Handling Middleware
07:38
Communicating More Info to the Error Handler
05:23
Encoding More Information In an Error
04:35
Subclassing for Custom Errors
08:17
Determining Error Type
03:10
Converting Errors to Responses
10:12
Moving Logic Into Errors
08:36
Verifying Our Custom Errors
08:34
Final Error Related Code
10:19
How to Define New Custom Errors
05:01
Uh Oh... Async Error Handling
05:49
+ Database Management and Modeling
16 lectures 01:27:13
Creating Databases in Kubernetes
08:25
Connecting to MongoDB
07:53
Understanding the Signup Flow
04:25
Getting TypeScript and Mongoose to Cooperate
05:21
Creating the User Model
04:54
Type Checking User Properties
06:01
Adding Static Properties to a Model
06:00
Defining Extra Document Properties
04:53
What's That Angle Bracket For?
03:52
User Creation
06:47
Proper Error Handling
07:25
Note on Password Hashing
00:35
Reminder on Password Hashing
04:58
Adding Password Hashing
06:57
Comparing Hashed Password
02:54
Mongoose Pre-Save Hooks
05:53
+ Authentication Strategies and Options
26 lectures 02:48:03
Fundamental Authentication Strategies
08:58
Huge Issues with Authentication Strategies
07:32
So Which Option?
02:58
Solving Issues with Option #2
08:26
Reminder on Cookies vs JWT's
06:21
Microservices Auth Requirements
11:00
Issues with JWT's and Server Side Rendering
09:58
Cookies and Encryption
04:51
Adding Session Support
03:11
Generating a JWT
08:29
JWT Signing Keys
04:56
Securely Storing Secrets with Kubernetes
02:13
Creating and Accessing Secrets
09:18
Accessing Env Variables in a Pod
05:18
Common Response Properties
04:41
Formatting JSON Properties
10:38
The Signin Flow
07:49
Common Request Validation Middleware
05:33
Sign In Logic
06:49
Quick Sign In Test
01:53
Current User Handler
03:01
Returning the Current User
08:55
Signing Out
02:48
Creating a Current User Middleware
06:55
Augmenting Type Definitions
07:46
Requiring Auth for Route Access
07:46
+ Testing Isolated Microservices
17 lectures 01:20:20
Scope of Testing
04:28
Testing Goals
04:32
Testing Architecture
07:51
Index to App Refactor
02:54
A Few Dependencies
03:33
Test Environment Setup
08:12
Our First Test
06:24
An Important Note
01:31
Testing Invalid Input
05:13
Requiring Unique Emails
01:45
Changing Node Env During Tests
05:43
Tests Around Sign In Functionality
06:26
Testing Sign Out
04:31
Issues with Cookies During Testing
05:18
Easy Auth Solution
03:03
Auth Helper Function
07:12
Testing Non-Authed Requests
01:44
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 Works

This 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 Use

Because 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 Do

By the time you complete this course, you will be able to:

  • Architect a multi-service application

  • Determine whether your app is a good fit for a microservices approach

  • Understand and solve the challenges in async, event-based communication between services

  • Use Docker and Kubernetes to deploy a multi-service app to any cloud provider

  • Organize and enhance the reusability of code in large projects


What You'll Learn

An 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 domains

  • Build a Server-Side-Rendered React app using Hooks and Next JS

  • Write a custom implementation of an event bus

  • Optionally, run a development environment through a cloud provider

  • Guarantee consistently structured responses from your different API's

  • See best practices in communication between different services

  • Configure and scale your services using Kubernetes Deployments

  • Document and enforce structure constraints on events shared across microservices

  • Limit access to your APIs using JWT-based authentication

  • And 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!

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