Udemy
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
Development
Web Development Data Science Mobile Development Programming Languages Game Development Database Design & Development Software Testing Software Engineering Development Tools No-Code Development
Business
Entrepreneurship Communications Management Sales Business Strategy Operations Project Management Business Law Business Analytics & Intelligence Human Resources Industry E-Commerce Media Real Estate Other Business
Finance & Accounting
Accounting & Bookkeeping Compliance Cryptocurrency & Blockchain Economics Finance Finance Cert & Exam Prep Financial Modeling & Analysis Investing & Trading Money Management Tools Taxes Other Finance & Accounting
IT & Software
IT Certification Network & Security Hardware Operating Systems Other IT & Software
Office Productivity
Microsoft Apple Google SAP Oracle Other Office Productivity
Personal Development
Personal Transformation Personal Productivity Leadership Career Development Parenting & Relationships Happiness Esoteric Practices Religion & Spirituality Personal Brand Building Creativity Influence Self Esteem & Confidence Stress Management Memory & Study Skills Motivation Other Personal Development
Design
Web Design Graphic Design & Illustration Design Tools User Experience Design Game Design Design Thinking 3D & Animation Fashion Design Architectural Design Interior Design Other Design
Marketing
Digital Marketing Search Engine Optimization Social Media Marketing Branding Marketing Fundamentals Marketing Analytics & Automation Public Relations Advertising Video & Mobile Marketing Content Marketing Growth Hacking Affiliate Marketing Product Marketing Other Marketing
Lifestyle
Arts & Crafts Beauty & Makeup Esoteric Practices Food & Beverage Gaming Home Improvement Pet Care & Training Travel Other Lifestyle
Photography & Video
Digital Photography Photography Portrait Photography Photography Tools Commercial Photography Video Design Other Photography & Video
Health & Fitness
Fitness General Health Sports Nutrition Yoga Mental Health Dieting Self Defense Safety & First Aid Dance Meditation Other Health & Fitness
Music
Instruments Music Production Music Fundamentals Vocal Music Techniques Music Software Other Music
Teaching & Academics
Engineering Humanities Math Science Online Education Social Science Language Teacher Training Test Prep Other Teaching & Academics
AWS Certification Microsoft Certification AWS Certified Solutions Architect - Associate AWS Certified Cloud Practitioner CompTIA A+ Cisco CCNA CompTIA Security+ Amazon AWS Microsoft AZ-900
Graphic Design Photoshop Adobe Illustrator Drawing Digital Painting InDesign Character Design Canva Figure Drawing
Life Coach Training Neuro-Linguistic Programming Personal Development Personal Transformation Mindfulness Life Purpose Meditation CBT Emotional Intelligence
Web Development JavaScript React CSS Angular PHP Node.Js WordPress Vue JS
Google Flutter Android Development iOS Development React Native Swift Dart Programming Language Mobile Development Kotlin SwiftUI
Digital Marketing Google Ads (Adwords) Social Media Marketing Google Ads (AdWords) Certification Marketing Strategy Internet Marketing YouTube Marketing Email Marketing Retargeting
Microsoft Power BI SQL Tableau Business Analysis Data Modeling Business Intelligence MySQL Data Analysis Blockchain
Business Fundamentals Entrepreneurship Fundamentals Business Strategy Business Plan Startup Freelancing Online Business Blogging Home Business
Unity Game Development Fundamentals Unreal Engine C# 3D Game Development C++ 2D Game Development Unreal Engine Blueprints Blender
30-Day Money-Back Guarantee
Development Web Development Microservices

Microservices with Node JS and React

Build, deploy, and scale an E-Commerce app using Microservices built with Node, React, Docker and Kubernetes
Bestseller
Rating: 4.8 out of 54.8 (6,289 ratings)
43,065 students
Created by Stephen Grider
Last updated 4/2021
English
English [Auto]
30-Day Money-Back Guarantee

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!
Curated for the Udemy for Business collection

Course content

26 sections • 617 lectures • 54h 15m total length

  • Preview00:56
  • Join Our Community!
    00:07
  • Preview03:19
  • Preview07: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

  • 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
  • Important Note about Node v15 and Unhandled Promise Rejections
    00:27
  • Event Syncing in Action
    04:16

  • 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

  • Installing Kubernetes
    03:19
  • Note for Minikube Users and the Docker Driver
    00:16
  • A Kubernetes Tour
    09:45
  • Important Kubernetes Terminology
    02:51
  • Notes on Config Files
    03:11
  • Creating a Pod
    06:41
  • ErrImagePull, ErrImageNeverPull and ImagePullBackoff Errors
    00:35
  • 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
  • Important Note About Port 80
    00:35
  • Hosts File Tweak
    06:15
  • Important Note to Add Environment Variable
    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

  • 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

  • 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

  • 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

  • Creating Databases in Kubernetes
    08:25
  • Important Update Regarding Mongoose and TypeScript
    00:27
  • 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

  • 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

  • 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

Featured review

Kennedy Otis
Kennedy Otis
113 courses
7 reviews
Rating: 5.0 out of 512 months ago
I have not finished but so far this is what I have been waiting for to show up. Been hearing about microservices but never got a course to teach on how to implement. The ones I came across were simply a joke. Am glad and thank you Stephen for taking time into making this course. Dream come true over here. I would like to ask if it will be possible to get Golang microservice course.

Instructor

Stephen Grider
Engineering Architect
Stephen Grider
  • 4.7 Instructor Rating
  • 295,026 Reviews
  • 780,625 Students
  • 29 Courses

Stephen Grider has been building complex Javascript front ends for top corporations in the San Francisco Bay Area.  With an innate ability to simplify complex topics, Stephen has been mentoring engineers beginning their careers in software development for years, and has now expanded that experience onto Udemy, authoring the highest rated React course. He teaches on Udemy to share the knowledge he has gained with other software engineers.  Invest in yourself by learning from Stephen's published courses.

  • Udemy for Business
  • Teach on Udemy
  • Get the app
  • About us
  • Contact us
  • Careers
  • Blog
  • Help and Support
  • Affiliate
  • Impressum Kontakt
  • Terms
  • Privacy policy
  • Cookie settings
  • Sitemap
  • Featured courses
Udemy
© 2021 Udemy, Inc.