When you enroll through our links, we may earn a small commission—at no extra cost to you. This helps keep our platform free and inspires us to add more value.

Udemy logo

Microservices with Node JS and React

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

     
  • 4.7
  •  |
  • Reviews ( 20K )
₹859

This Course Includes

  • iconudemy
  • icon4.7 (20K reviews )
  • icon54h 23m
  • iconenglish
  • iconOnline - Self Paced
  • iconprofessional certificate
  • iconUdemy

About Microservices with Node JS and React

Event-Based Architecture?

Covered!

Server side rendering with React?

Yep.

Scalable, production-ready code?

Its here! _This course requires you to download Docker Desktop from Docker. If you are a Udemy Business user, please check with your employer before downloading software._ 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!

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!.