مطالب پیشنهادی از سراسر وب

آموزش میکروسرویس ها با Node JS و React

دسته بندی ها: آموزش های ویژه ، آموزش نود جی اس (Node.js) ، آموزش طراحی وب ، آموزش ری اکت (React) ، آموزش جاوا اسکریپت (Javascript) ، آموزش های یودمی (Udemy)

با استفاده از میکروسرویس های ساخته شده با Node ،React ،Docker و Kubernetes، یک برنامه تجارت الکترونیکی ایجاد، استقرار و مقیاس بندی کنید.

آخرین به روز رسانی: 2021-1

آنچه خواهید آموخت:

  • با استفاده از مجموعه ای از میکروسرویس ها، برنامه های بزرگ و مقیاس پذیر را معماری کنید
  • با استفاده از Docker و Kubernetes، یک برنامه multi-service را در فضای ابری مستقر کنید
  • مسائل مربوط به همزمانی را در محیط سیستم های توزیع شده حل کنید
  • برای ساختن یک برنامه وب پیچیده از مهارت های Javascript خود استفاده کنید
  • اپلیکیشن ری اکت رندر شده سمت سرور را برای رندر داده از میکروسرویس ها ایجاد کنید
  • بدانید که شرکت های سازمانی چگونه زیرساخت های خود را طراحی می کنند
  • با استفاده از بسته های NPM سفارشی کد قابل استفاده مجدد را بین چندین سرور Express به اشتراک بگذارید
  • برای اطمینان از عملکرد هر سرویس مطابق طراحی، تست های جامعی بنویسید
  • با استفاده از event bus سریع، داده ها را بین سرویس ها برقرار کنید
  • چیزی جز کد در سطح تولید ننویسید. 

الزامات دوره:

  • دانش اولیه Javascript و Express مورد نیاز است
  • دانش React خوب است، اما لازم نیست
  • شما باید با خط فرمان آشنا باشید

توضیحات دوره:

معماری مبتنی بر رویداد؟ در این دوره پوشش داده شده است! رندر سمت سرور با React؟ بله. مقیاس پذیری، کد آماده تولید؟بله همگی در این دوره آموزش داده می شود!

میکروسرویس ها راه حل شماره یک برای ساخت و مقیاس گذاری برنامه هایی هستند که برای رشد در نظر گرفته شده اند. فقط یک مسئله کوچک است: منابع آنلاین کمی وجود دارد که به پیچیده ترین مسائل پیرامون آن بپردازند! این دوره برای رفع آن مسائل ایجاد شده است. این دوره به طور عمده مشکلات اساسی درمورد میکروسرویس ها را برطرف می کند. از چالش های مربوط به تکثیر داده ها تا جریان های نامرتب گیج کننده، همه چالش های اساسی ایجاد میکروسرویس ها تحت پوشش قرار می گیرند.

فراتر از تمرکز بر مبانی Microservices، این دوره مقدمه ای کامل برای دنیای توسعه full-stack است. شما از فرانت اند، مونتاژ یک برنامه React با استفاده از Hooks تا بک اند، از جمله طراحی پایگاه داده و استراتژی های استقرار، را یاد خواهید گرفت. هر مرحله از مسیر با جزئیات فوق العاده و نمودارهای کافی برای اطمینان از شفاف بودن هر مرحله پوشش داده شده است.

بسیاری از منابع دیگر تنها ساده ترین برنامه های نوشته شده توسط میکروسرویس ها را نشان می دهند. این دوره برعکس عمل می کند: ما بر چالش برانگیزترین جنبه های میکروسرویس ها تمرکز می کنیم، چالش هایی که احتمالاً هر روز با آنها روبرو خواهید شد. این مشکلات را از نزدیک خواهید دید، سپس آنها را با راهکارهای قابل درک حل می کنید.

نحوه کار این دوره:

این دوره بر روی استفاده از فریمورک میکروسرویس های off-the-shelf متمرکز نیست. بسیاری وجود دارند، اما عملکردهای داخلی و چالش های میکروسرویس ها را از شما پنهان می کنند. در عوض، ما از حداقل تعداد کتابخانه استفاده خواهیم کرد و تا آنجا که ممکن است کد سفارشی می نویسیم. این امر شما را در معرض مشکلات چالش برانگیز و راه حل های هوشمندانه هنگام مدیریت موضوعاتی مانند رویدادهای همزمان سازی قرار می دهد!

از چه فناوری استفاده خواهید کرد؟

از آنجا که ما در حال ساخت یک برنامه full stack هستیم، از انواع فن آوری ها استفاده خواهیم کرد. در فرانت اند، ما از React و Next JS برای ارائه محتوا به کاربران استفاده خواهیم کرد. هر سرویس با استفاده از Node و Express ایجاد می شود. داده های هر سرویس یا در یک پایگاه داده Mongo یا Redis نگهداری می شود. کل برنامه در کانتینرهای داکر اجرا شده در یک خوشه Kubernetes مستقر شده و اجرا می شود. سرانجام، تقریباً تمام کدهای این دوره با Typescript نوشته شده اند.

این یک لیست ترسناک از فناوری ها است! آیا با بعضی از اینها آشنا نیستید؟ مشکلی نیست این دوره با این فرض ساخته می شود که شما فقط اصول Javascript و Express را می دانید. هیچ دانش دیگری لازم نیست - شما همه چیزهایی را که باید بدانید یاد خواهید گرفت.

آنچه شما قادر به انجام آن خواهید بود:

با اتمام این دوره، شما قادر خواهید بود:

  • یک برنامه multi-service را معماری کنید
  • تعیین کنید آیا برنامه شما برای رویکرد microservices مناسب است یا خیر
  • درک و حل چالش های موجود در هم زمان سازی، ارتباط مبتنی بر رویداد بین سرویس ها
  • از Docker و Kubernetes برای استقرار یک برنامه multi-service در هر ارائه دهنده ابری استفاده کنید
  • قابلیت استفاده مجدد کد را در پروژه های بزرگ سازماندهی و افزایش دهید

موضوعاتی که یاد خواهید گرفت:

تعداد کاملاً باورنکردنی موضوعاتی که در این دوره پوشش داده شده است به صورت جزئی در زیر لیست شده است:

  • الگوها را برای ایجاد میکروسرویس های مقیاس پذیر برای دامنه های مختلف برنامه تمرین کنید
  • با استفاده از Hooks و Next JS یک برنامه React رندر شده سمت سرور بسازید
  • پیاده سازی سفارشی یک event bus را بنویسید
  • به صورت اختیاری، یک محیط توسعه را از طریق یک ارائه دهنده Cloud اجرا کنید
  • پاسخ های ساختاری مداوم از API های مختلف خود را تضمین کنید
  • بهترین روش ها را در برقراری ارتباط بین سرویس های مختلف مشاهده کنید
  • خدمات خود را با استفاده از Kubernetes Deployments پیکربندی و مقیاس بندی کنید
  • محدودیت های ساختاری را در رویدادهای مشترک بین میکروسرویس ها ثبت و اعمال کنید
  • با احراز هویت مبتنی بر JWT دسترسی به API های خود را محدود کنید
  • و خیلی بیشتر!

این دوره برای چه کسانی مناسب است:

  • مهندسین Javascript  که به دنبال ساختن برنامه های بزرگ و قابل مقیاس هستند
  • این دوره برای sysadmins متمرکز بر استقرار زیرساخت ها طراحی نشده است

سرفصل های دوره:

  • ایده های اساسی پیرامون میکروسرویس ها
  • اپلیکیشن Mini-Microservices
  • اجرای سرویس ها با داکر
  • ارکستراسیون مجموعه های سرویس ها با Kubernetes
  • معماری اپلیکیشن های Multi-Service
  • استفاده از محیط ابری برای توسعه
  • استراتژی های نرمال سازی پاسخ
  • مدل سازی و مدیریت پایگاه داده
  • راهکارها و گزینه های احراز هویت
  • تست کردن میکروسرویس های جدا شده
  • یکپارچه سازی یک اپلیکیشن ری اکت رندر شده سمت سرور
  • اشتراک کد و استفاده مجدد بین سرویس ها
  • راه اندازی سرور - تخریب - به روزرسانی - خواندن - ایجاد
  • سرور NATS Streaming - پیاده سازی Event Bus 
  • اتصال NATS به دنیای Node JS
  • مدیریت NATS Client
  • تکثیر داده های Cross-Service در عمل
  • درک کردن Event Flow
  • گوش دادن به رویدادها و مدیریت مسائل هم زمان
  • Worker Services
  • مدیریت پرداخت ها
  • بازگشت به کلاینت
  • CI/CD
  • [پیوست اول] - مبانی داکر
  • [ضمیمه دوم] - اصول تایپ اسکریپت
  • جایزه

سایر ویدئوهای دوره:

میکروسرویس چیست؟

 

داده در میکروسرویس ها

 

مشکلات بزرگ با داده

 

سینک کردن ارتباطات بین سرویس ها

 

ارتباطات رویداد محور

 

روش دیوانه وار ذخیره ی داده

 

جوانب مثبت و منفی ارتباطات Async

آیا این نوشته را دوست داشتید؟
Udemy Microservices with Node JS and React Publisher:Udemy Author:Stephen Grider Duration:54 hours Level:Advanced

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

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

Course content

26 sections • 617 lectures • 54h 14m total length
Fundamental Ideas Around Microservices
9 lectures • 45min
How to Get Help
Preview
00:56
Join Our Community!
00:07
What Is a Microservice?
Preview
03:19
Data in Microservices
Preview
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
39 lectures • 3hr 33min
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
Running Services with Docker
7 lectures • 29min
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
40 lectures • 3hr 21min
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
Architecture of Multi-Service Apps
12 lectures • 1hr 5min
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 • 47min
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 • 1hr 58min
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
17 lectures • 1hr 28min
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
Authentication Strategies and Options
26 lectures • 2hr 48min
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 • 1hr 20min
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
Integrating a Server-Side-Rendered React App
37 lectures • 3hr 1min
Starting the React App
02:11
Reminder on Server Side Rendering
03:38
Basics of Next JS
05:24
Building a Next Image
04:28
Running Next in Kubernetes
10:12
Note on File Change Detection
04:26
Adding Global CSS
05:09
Adding a Sign Up Form
03:11
Handling Email and Password Inputs
03:42
Successful Account Signup
05:12
Handling Validation Errors
06:53
The useRequest Hook
06:59
Using the useRequest Hook
03:40
An onSuccess Callback
05:37
Overview on Server Side Rendering
06:47
Fetching Data During SSR
05:07
Why the Error?
09:00
Two Possible Solutions
07:04
Cross Namespace Service Communication
07:45
When is GetInitialProps Called?
06:46
On the Server or the Browser
02:01
Ingress-Nginx Namespace and Service for Docker Desktop
00:17
Ingress-Nginx Namespace and Service for Minikube
01:21
Specifying the Host
08:23
Passing Through the Cookies
04:01
A Reusable API Client
07:05
Content on the Landing Page
02:01
The Sign In Form
03:12
A Reusable Header
05:00
Moving GetInitialProps
02:11
Issues with Custom App GetInitialProps
06:42
Handling Multiple GetInitialProps
06:07
Passing Props Through
03:03
Building the Header
05:05
Conditionally Showing Links
05:58
Signing Out
04:36
React App Catchup
00:33
Code Sharing and Reuse Between Services
9 lectures • 51min
Shared Logic Between Services
04:34
Options for Code Sharing
04:46
NPM Organizations
04:27
Publishing NPM Modules
04:06
Project Setup
07:34
An Easy Publish Command
07:26
Relocating Shared Code
07:29
Updating Import Statements
05:16
Updating the Common Module
05:34
Create-Read-Update-Destroy Server Setup
25 lectures • 2hr 27min
Ticketing Service Overview
03:03
Project Setup
05:24
Running the Ticket Service
06:05
Mongo Connection URI
08:13
Quick Auth Update
01:47
Test-First Approach
04:19
Creating the Router
04:56
Adding Auth Protection
08:04
Faking Authentication During Tests
07:09
Building a Session
05:39
Testing Request Validation
04:12
Validating Title and Price
04:09
Reminder on Mongoose with TypeScript
07:12
Defining the Ticket Model
03:48
Creation via Route Handler
08:21
Testing Show Routes
06:52
Unexpected Failure!
05:29
What's that Error?!
08:57
Better Error Logging
05:11
Complete Index Route Implementation
06:31
Ticket Updating
06:15
Handling Updates
04:15
Permission Checking
06:49
Final Update Changes
09:04
Manual Testing
05:36
NATS Streaming Server - An Event Bus Implementation
22 lectures • 2hr 56min
What Now?
02:50
Three Important Items
04:34
Creating a NATS Streaming Deployment
06:25
Big Notes on NATS Streaming
09:53
Building a NATS Test Project
07:31
Small Command Change
00:21
Port-Forwarding with Kubectl
04:40
Publishing Events
06:20
Listening For Data
06:55
Accessing Event Data
06:56
Client ID Generation
04:48
Queue Groups
07:28
Manual Ack Mode
09:51
Client Health Checks
09:45
Graceful Client Shutdown
06:42
Core Concurrency Issues
12:56
Common Questions
08:08
[Optional] More Possible Concurrency Solutions
16:42
Solving Concurrency Issues
20:05
Concurrency Control with the Tickets App
09:40
Event Redelivery
04:34
Durable Subscriptions
08:59
Connecting to NATS in a Node JS World
17 lectures • 1hr 22min
Reusable NATS Listeners
04:32
The Listener Abstract Class
09:27
Extending the Listener
05:53
Quick Refactor
03:17
Leveraging TypeScript for Listener Validation
05:28
Subjects Enum
03:28
Custom Event Interface
02:26
Enforcing Listener Subjects
07:22
Quick Note: 'readonly' in Typescript
00:25
Enforcing Data Types
03:53
Where Does this Get Used?
02:49
Custom Publisher
08:11
Using the Custom Publisher
03:50
Awaiting Event Publication
04:28
Common Event Definitions Summary
06:26
Updating the Common Module
07:35
Restarting NATS
02:09
Managing a NATS Client
17 lectures • 1hr 37min
Publishing Ticket Creation
03:48
More on Publishing
03:19
NATS Client Singleton
05:24
Remember Mongoose?
04:57
Singleton Implementation
09:04
Accessing the NATS Client
04:28
Graceful Shutdown
06:55
Successful Listen!
03:23
Ticket Update Publishing
04:28
Failed Event Publishing
07:03
Handling Publish Failures
06:02
Fixing a Few Tests
03:52
Redirecting Imports
05:35
Providing a Mock Implementation
09:09
Test-Suite Wide Mocks
02:12
Ensuring Mock Invocations
09:13
NATS Env Variables
08:00
Cross-Service Data Replication In Action
26 lectures • 2hr 43min
The Orders Service
05:02
Scaffolding the Orders Service
04:39
A Touch More Setup
07:32
Ingress Routing Rules
01:53
Scaffolding a Few Route Handlers
09:55
Subtle Service Coupling
06:43
Associating Orders and Tickets
06:49
Order Model Setup
08:52
The Need for an Enum
05:56
Creating an Order Status Enum
08:31
More on Mongoose Refs
02:58
Defining the Ticket Model
07:09
Order Creation Logic
05:45
Finding Reserved Tickets
06:10
Convenience Document Methods
07:37
Order Expiration Times
06:05
Test Suite Setup
02:36
Asserting Tickets Exist
06:08
Asserting Reserved Tickets
05:05
Testing the Success Case
04:09
Fetching a User's Orders
05:23
A Slightly Complicated Test
12:23
Fetching Individual Orders
04:36
Does Fetching Work?
07:17
Cancelling an Order
04:32
Can We Cancel?
09:12
Understanding Event Flow
6 lectures • 30min
Orders Service Events
04:43
Creating the Events
09:23
Implementing the Publishers
03:13
Publishing the Order Creation
05:03
Publishing Order Cancellation
02:33
Testing Event Publishing
05:32
Listening for Events and Handling Concurrency Issues
45 lectures • 4hr 12min
Time for Listeners!
02:12
Reminder on Listeners
01:53
Blueprint for Listeners
03:39
A Few More Reminders
05:26
Simple onMessage Implementation
02:17
ID Adjustment
05:44
Ticket Updated Listener Implementation
04:32
Initializing the Listeners
02:44
A Quick Manual Test
03:16
Clear Concurrency Issues
12:59
Reminder on Versioning Records
06:41
Optimistic Concurrency Control
05:37
Mongoose Update-If-Current
03:46
Implementing OCC with Mongoose
04:02
Testing OCC
09:07
One More Test
03:45
Who Updates Versions?
06:29
Including Versions in Events
02:59
Updating Tickets Event Definitions
03:55
Applying a Version Query
07:14
Did it Work?
04:31
Abstracted Query Method
05:42
[Optional] Versioning Without Update-If-Current
18:34
Testing Listeners
04:55
A Complete Listener Test
09:25
Testing the Ack Call
02:09
Testing the Ticket Updated Listener
08:20
Success Case Testing
04:49
Out-Of-Order Events
04:51
The Next Few Videos
03:39
Fixing a Few Tests
06:36
Listeners in the Tickets Service
01:47
Building the Listener
04:59
Strategies for Locking a Ticket
05:28
Reserving a Ticket
03:42
Setup for Testing Reservation
07:00
Test Implementation
04:29
Missing Update Event
06:14
Private vs Protected Properties
06:54
Publishing While Listening
06:42
Mock Function Arguments
09:49
Order Cancelled Listener
06:51
A Lightning-Quick Test
07:28
Don't Forget to Listen!
02:21
Rejecting Edits of Reserved Tickets
06:15
Worker Services
19 lectures • 1hr 36min
The Expiration Service
02:38
Expiration Options
07:55
Initial Setup
06:14
A Touch of Kubernetes Setup
07:44
File Sync Setup
02:32
Listener Creation
03:42
What's Bull All About?
03:56
Creating a Queue
09:07
Queueing a Job on Event Arrival
05:10
Testing Job Processing
03:17
Delaying Job Processing
05:23
Defining the Expiration Complete Event
03:50
Publishing an Event on Job Processing
06:27
Handling an Expiration Event
06:00
Emitting the Order Cancelled Event
05:37
Testing the Expiration Complete Listener
05:51
A Touch More Testing
07:20
Listening for Expiration
02:20
Don't Cancel Completed Orders!
01:01
Handling Payments
28 lectures • 2hr 38min
The Payments Service
02:11
Initial Setup
08:45
Replicated Fields
05:57
Another Order Model!
07:30
Update-If-Current
01:17
Replicating Orders
04:07
Testing Order Creation
06:12
Marking an Order as Cancelled
05:39
Cancelled Testing
06:42
Starting the Listeners
03:54
Payments Flow with Stripe
05:10
Implementing the Create Charge Handler
08:32
Validating Order Payment
04:03
Testing Order Validation Before Payment
06:59
Testing Same-User Validation
05:10
Stripe Setup
03:58
Creating a Stripe Secret
03:20
Creating a Charge with Stripe
06:08
Manual Testing of Payments
06:35
Automated Payment Testing
06:27
Mocked Stripe Client
04:23
A More Realistic Test Setup
09:16
Realistic Test Implementation
06:15
Tying an Order and Charge Together
07:18
Testing Payment Creation
06:13
Publishing a Payment Created Event
06:31
More on Publishing
03:18
Marking an Order as Complete
06:18
Back to the Client
19 lectures • 1hr 43min
A Few More Pages
06:15
Reminder on Data Fetching with Next
06:09
Two Quick Fixes
05:43
Scaffolding a Form
03:43
Sanitizing Price Input
06:29
Ticket Creation
06:44
Listing All Tickets
07:41
Linking to Wildcard Routes
07:07
Creating an Order
07:25
Programmatic Navigation to Wildcard Routes
04:16
The Expiration Timer
10:54
Displaying the Expiration
01:01
Showing a Stripe Payment Form
03:06
Configuring Stripe
04:23
Test Credit Card Numbers
01:58
Paying for an Order
09:24
Filtering Reserved Tickets
02:27
Header Links
01:47
Rendering a List of Orders
06:20
CI/CD
30 lectures • 2hr 16min
Development Workflow
03:39
Git Repository Approaches
06:05
Creating a GitHub Action
07:11
Adding a CI Test Script
02:42
Running Tests on PR Creation
04:48
Output of Failing Tests
05:48
Running Tests in Parallel
07:28
Verifying a Test Run
03:01
Selective Test Execution
05:44
Deployment Options
07:40
Creating a Hosted Cluster
02:39
Reminder on Kubernetes Context
03:32
Reminder on Swapping Contexts
03:56
The Deployment Plan
04:04
Building an Image in an Action
08:40
Testing the Image Build
02:30
Restarting the Deployment
07:17
Applying Kubernetes Manifests
03:27
Prod vs Dev Manifest Files
04:23
Manual Secret Creation
03:39
Don't Forget Ingress-Nginx!
05:31
Testing Automated Deployment
02:51
Additional Deploy Files
07:12
A Successful Deploy!
06:07
Buying a Domain Name
03:10
Configuring the Domain Name
05:27
One Small Fix
00:36
One More Small Fix
00:18
I Really Hope This Works
01:58
Next Steps
04:36
[Appendix A] - Basics of Docker
49 lectures • 3hr 7min
Why Use Docker?
03:43
What is Docker?
02:53
Docker for Mac / Windows
01:57
Installing Docker on macOS
04:45
Installing Docker for Windows Home users
00:44
Installing Docker for Windows - Professional and Enterprise
02:03
More Windows Setup - Professional and Enterprise
00:40
One Last Piece of Windows Setup - Professional and Enterprise
01:09
Installing Docker on Linux
00:41
Using the Docker Client
05:03
But Really... What's a Container?
08:30
How's Docker Running on Your Computer?
02:44
Docker Run in Detail
01:54
Overriding Default Commands
05:12
Listing Running Containers
04:09
Container Lifecycle
05:16
Restarting Stopped Containers
03:43
Removing Stopped Containers
01:39
Retrieving Output Logs
02:33
Stopping Containers
05:21
Multi-Command Containers
04:16
Executing Commands in Running Containers
02:53
The Purpose of the 'it' Flag
04:35
Getting a Command Prompt in a Container
04:06
Starting with a Shell
02:13
Container Isolation
03:09
Creating Docker Images
02:36
Buildkit for Docker Desktop v2.4.0+ and Edge
00:34
Building a Dockerfile
04:51
Dockerfile Teardown
02:41
What's a Base Image?
05:40
The Build Process in Detail
11:09
A Brief Recap
03:24
Rebuilds with Cache
07:02
Tagging an Image
04:26
Quick Note for Windows Users
00:14
Manual Image Generation with Docker Commit
05:00
Project Outline
02:35
Node Server Setup
05:03
A Few Planned Errors
05:12
Resolving "npm ERR! could not detect node name from path or package"
00:16
Base Image Issues
07:50
A Few Missing Files
03:18
Copying Build Files
04:50
Reminder for Windows Home / Docker Toolbox Students
00:13
Container Port Forwarding
07:26
Specifying a Working Directory
07:52
Unnecessary Rebuilds
04:16
Minimizing Cache Busting and Rebuilds
04:58
[Appendix B] - Basics of Typescript
70 lectures • 5hr 40min
How to Get Help
01:04
TypeScript Overview
06:19
Environment Setup
07:59
A First App
04:43
Executing Typescript Code
05:03
One Quick Change
03:35
Catching Errors with TypeScript
07:22
Catching More Errors!
05:15
Do Not Skip - Course Overview
03:36
Types
05:12
More on Types
05:53
Examples of Types
04:48
Where Do We Use Types?
00:49
Type Annotations and Inference
02:03
Annotations With Variables
04:53
Object Literal Annotations
06:53
Annotations Around Functions
05:55
Understanding Inference
03:51
The Any Type
07:47
Fixing the "Any" Type
01:49
Delayed Initialization
03:05
When Inference Doesn't Work
04:37
Annotations Around Functions
04:56
Inference Around Functions
06:08
Annotations for Anonymous Functions
01:42
Void and Never
02:49
Destructuring with Annotations
03:35
Annotations Around Objects
07:05
Arrays in TypeScript
05:05
Why Typed Arrays?
04:30
Multiple Typees in Arrays
02:57
When to Use Typed Arrays
00:54
Tuples in TypeScript
04:04
Tuples in Action
05:28
Why Tuples?
03:20
Interfaces
01:26
Long Type Annotations
04:42
Fixing Annotations With Interfaces
04:36
Syntax Around Interfaces
03:31
Functions in Interfaces
04:46
Code Reuse with Interfaces
04:15
General Plan with Interfaces
03:12
Classes
03:47
Basic Inheritance
03:03
Class Method Modifiers
06:41
Fields in Classes
06:18
Fields with Inheritance
04:18
Where to Use Classes
01:09
App Overview
02:45
Parcel in Action
04:55
Project Structure
03:19
Generating Random Data
05:29
Type Definition Files
05:17
Using Type Definition Files
06:20
Export Statements in TypeScript
05:06
Defining a Company
04:43
Adding Google Maps Support
07:38
Google Maps Integration with TypeScript
04:06
Exploring Type Definition Files
12:46
Hiding Functionality
06:28
Why Use Private Modifiers? Here's Why
08:25
Adding Markers
09:18
Duplicate Code
02:45
One Possible Solution
06:38
Restricting Access with Interfaces
05:35
Implicit Type Checks
03:26
Showing Popup Windows
06:47
Updating Interface Definitions
07:11
Optional Implements Clauses
06:06
App Wrapup
08:08
Bonus!
1 lecture • 1min
Bonus!
00:14

پیشنهاد آموزش مرتبط در فرادرس

خرید لینک های دانلود
  • حجم فایل: 21.33GB
  • زبان: انگلیسی
  • زیرنویس انگلیسی: دارد
  • قیمت: 8000 تومان
  • آموزش میکروسرویس ها با Node JS و React یک محصول ویژه است و دریافت لینک های دانلود آن با پرداخت هزینه امکان پذیر است. اطلاعات بیشتر