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 employing a collection of microservices
• Deploy a multi-service app to the cloud with Docker and Kubernetes
• Solve concurrency issues during a distributed systems environment
• Leverage your Javascript skills to create a posh 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 make sure each service works as designed
• Communicate data between services employing a lightning-fast event bus
• Write nothing but production-level code. No cutting corners!
Basic knowledge of Javascript and Express is required
Knowledge of React is nice , but not needed
You must be familiar and comfy with the instruction
Event-Based Architecture? Covered! Server side rendering with React? Yep. Scalable, production-ready code? Its here!

Microservices are the quantity 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 foremost complex and nasty issues around them! I built this course to repair 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 roofed .

Beyond that concentrate on the basics of microservices, this course could also be an ideal introduction to the earth of full-stack development. you’ll 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 roofed in tremendous detail, with ample diagrams to form sure every step is crystal clear.

Many other resources show only the only , simplest apps written with microservices. This course does the opposite: we specialize in the foremost challenging aspects of microservices, challenges that you simply simply 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 specialize in using an off-the-shelf microservices framework. Many exist, but they hide the inner workings and challenges of microservices away from you. Instead, we’ll be employing a minimal number of libraries, and write the utmost amount custom code as possible. this might 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’ll use a selection of technologies. On the frontend, we’ll use React and Next JS to present content to users. Each service is formed 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 during a Kubernetes cluster. Finally, most of the code during this course is written with Typescript.

This is a scary list of technologies! Not familiar with variety of these? No problem! The course is formed assuming that you simply simply only know the basics of Javascript and Express. No other knowledge is required – you’ll learn everything you’d wish to understand .

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 could also be an honest fit 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 during this course. Here could also be a partial list of what you’ll do:

Practice patterns to form scalable microservices for a selection 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 once i used to be learning microservices. A course that focuses on the toughest parts, gives clear explanations, and discusses the pros and cons of varied design options. sign up today and join me in mastering microservices!

Who this course is for:
Javascript engineers looking to make large, scalable applications
This course is *not* designed for sysadmins focused on infrastructure deployment
Featured review
I have not finished but so far this is often often what I even are expecting to means up. Been hearing about microservices but never got a course to point out on the thanks to implement. those I found were simply a joke. Am glad and lots of thanks Stephen for taking time into making this course. Dream come true here . i’d wish to ask if it’ll be possible to urge Golang microservice course.

Course content
• 26 sections • 617 lectures • 54h 14m total length
• Fundamental Ideas Around Microservices
• A Mini-Microservices App
• Running Services with Docker
• Orchestrating Collections of Services with Kubernetes
• Architecture of Multi-Service Apps
• Leveraging a Cloud Environment for Development
• Response Normalization Strategies
• Database Management and Modeling
• Authentication Strategies and Options
• Testing Isolated Microservices
• Integrating a Server-Side-Rendered React App
• Code Sharing and Reuse Between Services
• Create-Read-Update-Destroy Server Setup
• NATS Streaming Server – an event Bus Implementation
• Connecting to NATS during a Node JS World
• Managing a NATS Client
• Cross-Service Data Replication In Action
• Understanding Event Flow
• Listening for Events and Handling Concurrency Issues
• Worker Services
• Handling Payments
• Back to the Client
• [Appendix A] – Basics of Docker
• [Appendix B] – Basics of Typescript
• Bonus!

Created by: Stephen Grider, Engineering Architect
Last updated 12/2020
English [Auto]
Direct Download Available
Rating: 4.8 out of 54.8
(5,305 ratings)
37,315 students

Please wait you can get the course in 30 Seconds....

Add a Comment

Your email address will not be published. Required fields are marked *