Udemy

Platform

English

Language

Web Development

Category

Microservices with Node JS and React

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

4.76 (6097 reviews)

41688

Students

54.5 hours

Content

Apr 2021

Last Update
$169.99
Regular Price


What you will 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!


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!


Screenshots

Microservices with Node JS and React
Microservices with Node JS and React
Microservices with Node JS and React
Microservices with Node JS and React

Content

Fundamental Ideas Around Microservices

How to Get Help

What Is a Microservice?

Data in Microservices

Quiz - Data in Microservices

Big Problems with Data

Sync Communication Between Services

Event-Based Communication

A Crazy Way of Storing Data

Pros and Cons of Async Communication

A Mini-Microservices App

App Overview

Project Setup

Posts Service Creation

Testing the Posts Service

Implementing a Comments Service

Quick Comments Test

Note on the React App

React Project Setup

Building Post Submission

Handling CORS Errors

Fetching and Rendering Posts

Creating Comments

Displaying Comments

Completed React App

Request Minimization Strategies

An Async Solution

Common Questions Around Async Events

Event Bus Overview

A Basic Event Bus Implementation

Emitting Events

Emitting Comment Creation Events

Receiving Events

Creating the Data Query Service

Parsing Incoming Events

Using the Query Service

Adding a Simple Feature

Issues with Comment Filtering

A Second Approach

How to Handle Resource Updates

Creating the Moderation Service

Adding Comment Moderation

Handling Moderation

Updating Comment Content

A Quick Test

Rendering Comments by Status

Dealing with Missing Events

Implementing Event Sync

Event Syncing in Action

Running Services with Docker

Deployment Issues

Why Docker?

Why Kubernetes?

Don't Know Docker? Watch This.

Dockerizing the Posts Service

Review Some Basic Commands

Dockering Other Services

Orchestrating Collections of Services with Kubernetes

Installing Kubernetes

A Kubernetes Tour

Important Kubernetes Terminology

Notes on Config Files

Creating a Pod

Understanding a Pod Spec

Common Kubectl Commands

A Time-Saving Alias

Introducing Deployments

Creating a Deployment

Common Commands Around Deployments

Updating Deployments

Preferred Method for Updating Deployments

Networking With Services

Creating a NodePort Service

Accessing NodePort Services

Setting Up Cluster IP Services

Building a Deployment for the Event Bus

Adding ClusterIP Services

How to Communicate Between Services

Updating Service Addresses

Verifying Communication

Adding Query, Moderation and Comments

Testing Communication

Load Balancer Services

Load Balancers and Ingress

Installing Ingress-Nginx

Writing Ingress Config Files

Hosts File Tweak

Deploying the Reat App

Unique Route Paths

Final Route Config

Introducing Skaffold

Skaffold Setup

First Time Skaffold Startup

A Few Notes on Skaffold

Architecture of Multi-Service Apps

Big Ticket Items

App Overview

Resource Types

Service Types

Events and Architecture Design

Note on Typescript

Auth Service Setup

Auth K8s Setup

Adding Skaffold

Note on Code Reloading

Ingress-Nginx Setup

Hosts File and Security Warning

Leveraging a Cloud Environment for Development

Note on Remote Development

Remote Dev with Skaffold

Google Cloud Initial Setup

Kubernetes Cluster Creation

Kubectl Contexts

Initializing the GCloud SDK

Installing the GCloud Context

Updating the Skaffold Config

More Skaffold Updates

Creating a Load Balancer

Final Config and Test

Response Normalization Strategies

Creating Route Handlers

Scaffolding Routes

Adding Validation

Handling Validation Errors

Postman HTTPS Issues

Surprising Complexity Around Errors

Other Sources of Errors

Solution for Error Handling

Building an Error Handling Middleware

Communicating More Info to the Error Handler

Encoding More Information In an Error

Subclassing for Custom Errors

Determining Error Type

Converting Errors to Responses

Moving Logic Into Errors

Verifying Our Custom Errors

Final Error Related Code

How to Define New Custom Errors

Uh Oh... Async Error Handling

Database Management and Modeling

Creating Databases in Kubernetes

Connecting to MongoDB

Understanding the Signup Flow

Getting TypeScript and Mongoose to Cooperate

Creating the User Model

Type Checking User Properties

Adding Static Properties to a Model

Defining Extra Document Properties

What's That Angle Bracket For?

User Creation

Proper Error Handling

Note on Password Hashing

Reminder on Password Hashing

Adding Password Hashing

Comparing Hashed Password

Mongoose Pre-Save Hooks

Authentication Strategies and Options

Fundamental Authentication Strategies

Huge Issues with Authentication Strategies

So Which Option?

Solving Issues with Option #2

Reminder on Cookies vs JWT's

Microservices Auth Requirements

Issues with JWT's and Server Side Rendering

Cookies and Encryption

Adding Session Support

Generating a JWT

JWT Signing Keys

Securely Storing Secrets with Kubernetes

Creating and Accessing Secrets

Accessing Env Variables in a Pod

Common Response Properties

Formatting JSON Properties

The Signin Flow

Common Request Validation Middleware

Sign In Logic

Quick Sign In Test

Current User Handler

Returning the Current User

Signing Out

Creating a Current User Middleware

Augmenting Type Definitions

Requiring Auth for Route Access

Testing Isolated Microservices

Scope of Testing

Testing Goals

Testing Architecture

Index to App Refactor

A Few Dependencies

Test Environment Setup

Our First Test

An Important Note

Testing Invalid Input

Requiring Unique Emails

Changing Node Env During Tests

Tests Around Sign In Functionality

Testing Sign Out

Issues with Cookies During Testing

Easy Auth Solution

Auth Helper Function

Testing Non-Authed Requests

Integrating a Server-Side-Rendered React App

Starting the React App

Reminder on Server Side Rendering

Basics of Next JS

Building a Next Image

Running Next in Kubernetes

Note on File Change Detection

Adding Global CSS

Adding a Sign Up Form

Handling Email and Password Inputs

Successful Account Signup

Handling Validation Errors

The useRequest Hook

Using the useRequest Hook

An onSuccess Callback

Overview on Server Side Rendering

Fetching Data During SSR

Why the Error?

Two Possible Solutions

Cross Namespace Service Communication

When is GetInitialProps Called?

On the Server or the Browser

Specifying the Host

Passing Through the Cookies

A Reusable API Client

Content on the Landing Page

The Sign In Form

A Reusable Header

Moving GetInitialProps

Issues with Custom App GetInitialProps

Handling Multiple GetInitialProps

Passing Props Through

Building the Header

Conditionally Showing Links

Signing Out

React App Catchup

Code Sharing and Reuse Between Services

Shared Logic Between Services

Options for Code Sharing

NPM Organizations

Publishing NPM Modules

Project Setup

An Easy Publish Command

Relocating Shared Code

Updating Import Statements

Updating the Common Module

Create-Read-Update-Destroy Server Setup

Ticketing Service Overview

Project Setup

Running the Ticket Service

Mongo Connection URI

Quick Auth Update

Test-First Approach

Creating the Router

Adding Auth Protection

Faking Authentication During Tests

Building a Session

Testing Request Validation

Validating Title and Price

Reminder on Mongoose with TypeScript

Defining the Ticket Model

Creation via Route Handler

Testing Show Routes

Unexpected Failure!

What's that Error?!

Better Error Logging

Complete Index Route Implementation

Ticket Updating

Handling Updates

Permission Checking

Final Update Changes

Manual Testing

NATS Streaming Server - An Event Bus Implementation

What Now?

Three Important Items

Creating a NATS Streaming Deployment

Big Notes on NATS Streaming

Building a NATS Test Project

Port-Forwarding with Kubectl

Publishing Events

Listening For Data

Accessing Event Data

Client ID Generation

Queue Groups

Manual Ack Mode

Client Health Checks

Graceful Client Shutdown

Core Concurrency Issues

Common Questions

[Optional] More Possible Concurrency Solutions

Solving Concurrency Issues

Concurrency Control with the Tickets App

Event Redelivery

Durable Subscriptions

Connecting to NATS in a Node JS World

Reusable NATS Listeners

The Listener Abstract Class

Extending the Listener

Quick Refactor

Leveraging TypeScript for Listener Validation

Subjects Enum

Custom Event Interface

Enforcing Listener Subjects

Enforcing Data Types

Where Does this Get Used?

Custom Publisher

Using the Custom Publisher

Awaiting Event Publication

Common Event Definitions Summary

Updating the Common Module

Restarting NATS

[Appendix A] - Basics of Docker

Why Use Docker?

What is Docker?

Docker for Mac / Windows

Installing Docker on macOS

Installing Docker for Windows Home users

Installing Docker for Windows - Professional and Enterprise

More Windows Setup - Professional and Enterprise

One Last Piece of Windows Setup - Professional and Enterprise

Installing Docker on Linux

Using the Docker Client

But Really... What's a Container?

How's Docker Running on Your Computer?

Docker Run in Detail

Overriding Default Commands

Listing Running Containers

Container Lifecycle

Restarting Stopped Containers

Removing Stopped Containers

Retrieving Output Logs

Stopping Containers

Multi-Command Containers

Executing Commands in Running Containers

The Purpose of the 'it' Flag

Getting a Command Prompt in a Container

Starting with a Shell

Container Isolation

Creating Docker Images

Building a Dockerfile

Dockerfile Teardown

What's a Base Image?

The Build Process in Detail

A Brief Recap

Rebuilds with Cache

Tagging an Image

Manual Image Generation with Docker Commit

Project Outline

Node Server Setup

A Few Planned Errors

Base Image Issues

A Few Missing Files

Copying Build Files

Reminder for Windows Home / Docker Toolbox Students

Container Port Forwarding

Specifying a Working Directory

Unnecessary Rebuilds

Minimizing Cache Busting and Rebuilds

[Appendix B] - Basics of Typescript

How to Get Help

TypeScript Overview

Environment Setup

A First App

Executing Typescript Code

One Quick Change

Catching Errors with TypeScript

Catching More Errors!

Do Not Skip - Course Overview

Types

More on Types

Examples of Types

Where Do We Use Types?

Type Annotations and Inference

Annotations With Variables

Object Literal Annotations

Annotations Around Functions

Understanding Inference

The Any Type

Fixing the "Any" Type

Delayed Initialization

When Inference Doesn't Work

Annotations Around Functions

Inference Around Functions

Annotations for Anonymous Functions

Void and Never

Destructuring with Annotations

Annotations Around Objects

Arrays in TypeScript

Why Typed Arrays?

Multiple Typees in Arrays

When to Use Typed Arrays

Tuples in TypeScript

Tuples in Action

Why Tuples?

Interfaces

Long Type Annotations

Fixing Annotations With Interfaces

Syntax Around Interfaces

Functions in Interfaces

Code Reuse with Interfaces

General Plan with Interfaces

Classes

Basic Inheritance

Class Method Modifiers

Fields in Classes

Fields with Inheritance

Where to Use Classes

App Overview

Parcel in Action

Project Structure

Generating Random Data

Type Definition Files

Using Type Definition Files

Export Statements in TypeScript

Defining a Company

Adding Google Maps Support

Google Maps Integration with TypeScript

Exploring Type Definition Files

Hiding Functionality

Why Use Private Modifiers? Here's Why

Adding Markers

Duplicate Code

One Possible Solution

Restricting Access with Interfaces

Implicit Type Checks

Showing Popup Windows

Updating Interface Definitions

Optional Implements Clauses

App Wrapup



Reviews

M
Marnix11 October 2020

The way Steven talks through each microservice challenge using Draw.io diagrams, it's really clear and he also adheres to a nice pace.

O
Orest11 October 2020

Very very deep and detailed explanation of every topic. Do not say that I surprised, because Stephen always shares knowledge at this level. At all I'm very happy that I get this course. 5+

y
y8 October 2020

this is totally the best course I have ever taken for over years. even though I don't speak English so much, the explanation is visually very understandable and quite in detail so that I could be very convinced. I really can recommend this course

E
Eduardo7 October 2020

You are a great teacher, and you included a lot of useful information in this course. I hope you continue making courses.

N
Nkemtakeh7 October 2020

The course is so awesome. Haven't even done 15% of it but I'm very sure I know what microservices is all about and I can implement something around it. So anxious to learn what the future lessons has to offer.

D
Dinesh1 October 2020

Learnt a lot in this course. Have to be prepared for a long course and persist. It was challenging initially learning with windows 8 running minikube, docker. Later in the course after moving to cloud things became smooth. Got a good understanding of microservice design. Thanks a lot Stephen!

A
Avi1 October 2020

one of the best online courses I had. I love how he doesn't get into basic stuff like, what is Axios? or what is async-await? or what is event loop? This is why this course is gold!!! you feel the progress from the first video.

E
Erwan1 October 2020

That the best course i ever took. If you want to really learn how software microservice architecture work with nodejs, you won't find better. Also, this is quite actual and i love the usage of github actions, great choice!

M
Miguel25 September 2020

Excellent diagrams to explain what the code is doing. Source code resources by lesson are really useful. Learned some good tips and tricks from a professional developer. Up to date with the latest in services, tools and practices. Tons of work on this course and excellent value for what I paid. To support such good course development, and to learn from a good teacher, I also bought additional courses from Stephen.

J
James24 April 2020

Your approach of thinking aloud and asking questions on how an engineer can approach different scenarios helped to stir my mind to thinking actively

A
Adam24 April 2020

Amazing course... this is modern enterprise architecture in one complete course. Great work Stephen!!

M
Modibo23 April 2020

This course teaches you everything you need to know to be among the best of the best microservices developers with a solid and deep knowledge of concepts and best practices of microservices. I do believe what makes this course the best of the best is not only Stephen Grider walks you through good microservices implementation examples but he does highlight the conceptual asides of microservices ,which many courses poorly address .The mini-microservices application section of the course is a vivid example of it. Truly Stephen always surprises me with his meticulously well organised courses and with his good sense of humour.Honestly I have never got bored when watching his courses. If a teacher should be only assessed by his expertise of what he teaches and his pedagogy skills decorated with his good sense of humour,Stephen Grider is the best of the best. He does not make at all courses to make money out of it but he makes it to teach you skills you will never have on your own in you career. Thank you,Stephen Grider, for everything.

A
Andreas23 April 2020

As an experienced developer, the first part of the course is at a very low level. That said, Stephen seems like a great instructor and the quality of the production is excellent. I am looking forward to the more complicated stuff

F
Fabio23 April 2020

Steve's courses are always really comprensive. He's one of the few teachers that follows the best practices and also always focuses on teaching how to include testing in the applications.

A
Abdullah22 April 2020

I just started on some of the videos and through the quick overviews of the apps that will be built, so I will update this review again once I do a major part of it, but so far this course is ambitious and super interesting. I am rating it as high based on my previous experience with Stephen in other courses and based on the potential outcome of this course as this doesn't look like any of the regular udemy apps you would find in terms of scope and coverage.



Coupons

StatusDateDiscount
Expired7/29/202094% OFF
Expired1/9/202192% OFF
Expired1/15/202194% OFF
Expired3/2/202192% OFF

2887266

Udemy ID

3/19/2020

Course created date

4/24/2020

Course Indexed date
Bot
Course Submitted by