Distributed System Design

Summary

本次讲座深入探讨了分布式系统的概念、优势和设计模式。分布式系统通过多台计算机的集群提高应用的可扩展性和容错性，适用于大数据和高并发场景。介绍了MapReduce框架、无状态与有状态系统、Raft一致性算法等关键组件，以及CQRS、两阶段提交和Saga等设计模式。这些模式有助于简化系统复杂性，提高数据处理效率，但也存在各自的优缺点。讲座强调了在系统开发中采用分布式框架的重要性，以及如何根据应用需求选择合适的设计模式和NoSQL数据库类型。

Takeaways

• 🌐 分布式系统使得开发可扩展的应用程序变得更容易，因为软件应用、数据和文件的增长需要大量存储空间。
• 🔄 当今许多公司使用复杂的分布式系统来处理各种请求和存储需求，以实现应用程序的全面可扩展性。
• 💡 分布式系统的特点是共享和同时操作相同状态的集合，且这些机器可以独立故障而不影响整个系统。
• 📈 分布式系统的优点包括可扩展性、模块化增长、容错性、成本效益、低延迟、高效性和并行计算。
• 🔄 可扩展性意味着应用程序能够通过不同平台工作，并允许与不同类型的系统进行水平通信。
• 🔧 容错性意味着如果一个机器或节点发生故障，其他机器或节点不会受到影响。
• 💰 成本效益表明，尽管分布式系统的初始成本高于传统系统，但由于其扩展能力，它们很快变得具有成本效益。
• 🚀 MapReduce 是 Google 开发的一个框架，用于高效处理大量数据，适用于大数据应用，如在线商店、社交网络站点等。
• 📊 分布式系统设计模式提供了一种构建适合特定用例的系统的方法，它们是允许我们利用现有知识而非从零开始构建系统的构建块。
• 🛠️ 分布式系统设计模式分为对象通信、安全性和事件驱动三类，帮助开发者理解如何构建和设计系统。
• 🔍 选择适合的分布式系统设计模式和NoSQL数据库类型对于系统开发至关重要，需要根据数据类型和所需信息来决定。

Q & A

分布式系统的主要优势是什么？

分布式系统的主要优势包括可扩展性、容错性、成本效益、低延迟、高效性和并行计算能力。这些系统能够处理大量数据，支持横向扩展，并能在多台计算机之间共享和同时操作相同状态，即使某些机器独立故障也不会影响整个系统。

MapReduce框架是如何帮助处理大数据的？

MapReduce框架通过将大数据处理划分为更小的部分来提高效率。它使用map和reduce两个阶段：map阶段处理数据并生成中间键值对，reduce阶段则对这些数据进行排序和汇总。这个过程允许用户专注于程序的高级逻辑，而不必关心底层的处理细节。

什么是无状态和有状态系统？

无状态系统不会保存任何关于过去事件的状态信息，它仅根据提供的输入执行操作。而有状态系统则负责维护和改变状态，这意味着它们会记录用户的操作历史和系统的变化。

Raft协议在分布式系统中扮演什么角色？

Raft协议在分布式系统中确保复制状态机的正确性和日志的一致性。它通过支持多个连续的共识轮次来实现节点之间的一致性，即使在节点故障的情况下也能保证系统的稳定性。

分布式系统设计模式有哪些主要类别？

分布式系统设计模式主要分为三类：对象通信、安全性和事件驱动。对象通信模式描述了系统不同组件之间的消息协议和权限；安全性模式处理系统的保密性、完整性和可用性；事件驱动模式描述了事件的生产、检测、消费和系统对事件的响应。

CQRS模式在分布式系统中的作用是什么？

CQRS（命令查询职责分离）模式通过分离读和写操作来提高分布式系统的可伸缩性和安全性。它使用命令来写入数据，并使用查询来检索数据，这样可以通过命令中心来处理数据的修改，并通过读服务来更新读模型，从而向用户展示变化。

两阶段提交（2PC）协议如何确保分布式事务的一致性？

两阶段提交（2PC）协议通过两个阶段——准备阶段和完成阶段——来确保分布式事务的一致性。在准备阶段，所有参与的服务被锁定并准备好发送数据；在完成阶段，协调者逐个解锁服务并请求其数据。一旦所有服务都准备好，它们就会被解锁以接受新任务。

Saga模式在处理分布式事务时有哪些优势？

Saga模式通过事件总线在微服务系统内部进行服务间的通信，每个参与的服务都会创建本地事务，并通过发布事件来触发其他服务的操作。这种模式的优势在于它可以处理更长的事务，适合去中心化的分布式系统，并且减少了瓶颈和来回通信。

为什么说分布式系统对于现代应用程序尤为重要？

现代应用程序，尤其是在线商店和社交网络站点，需要处理大量数据和请求。分布式系统框架使得这些应用程序能够通过多台计算机的集合来工作，仿佛它们是单一计算机一样，从而提供了可扩展性、高可用性和高效的数据处理能力。

在设计分布式系统时，应如何选择NoSQL数据库类型？

在选择NoSQL数据库类型时，应考虑数据的特性和所需的信息类型。有多种类型的NoSQL数据库，包括文档型、键值对型、列族型和图形数据库等，选择的依据是数据存储的需求和应用程序的具体用例。

分布式系统设计模式如何帮助开发者？

分布式系统设计模式为开发者提供了一套标准化的系统设计模型，帮助他们理解如何构建适用于特定用例的系统。这些模式是基于现有知识的构建块，允许开发者从已有的解决方案中汲取经验，而不是从头开始构建系统，从而提高开发效率和系统质量。

Outlines

00:00

🌐 分布式系统概述

本段介绍了分布式系统的基本概念，强调其在当今软件开发中的重要性。分布式系统使得开发可扩展的应用程序变得更加容易，因为现代软件应用的数据量和文件大小不断增长，需要更大的存储空间。许多公司使用复杂的分布式系统来处理各种请求和存储需求。分布式系统由多台计算机组成，这些计算机共享和同时运行相同的状态，并且可以独立故障而不影响整个系统。尽管分布式系统复杂且难以部署和维护，但它们提供了许多好处，如可扩展性、容错性、成本效益和低延迟。此外，还介绍了分布式系统的设计模式，如MapReduce框架，以及它们如何帮助处理大数据应用程序。

05:00

🚧 分布式系统可能遇到的故障

这一部分讨论了分布式系统可能遇到的故障类型，包括系统故障、通信故障、次要存储故障和方法故障。系统故障可能导致主存储器内容丢失，但次要存储器保持安全。通信故障可能由通信链路故障或节点移动引起。次要存储故障发生在次要存储设备上的信息无法访问时。方法故障可能导致分布式系统停止运行或无法执行任何操作。了解这些基本概念对于设计和维护分布式系统至关重要。

10:02

🔍 分布式系统的关键组件和设计模式

本段详细介绍了分布式系统的关键组件和设计模式。首先介绍了MapReduce框架，它是Google开发的用于高效处理大数据的框架。接着讨论了无状态和有状态系统的概念，以及Raft协议，它用于建立复制状态机的内容和相关的复制日志。此外，还探讨了分布式系统设计模式，它们提供了构建特定用例系统的标准化模型。这些模式分为对象通信、安全性和事件驱动三种类型，每种类型都有其特定的应用场景和优势。

15:03

🛠️ 常见的分布式系统设计模式

这一部分列举了五种常用的分布式系统设计模式，它们是构建特定场景系统的经过验证的方法。这些设计模式包括对象通信、安全性和事件驱动等方面。对象通信描述了系统不同组件之间的消息协议和权限。安全性处理了保密性、完整性和可用性等方面的问题。事件驱动则描述了系统事件的生产、检测、消费和响应。这些模式有助于开发者理解如何构建和设计分布式系统，以及如何在系统开发中重用代码。

20:05

📈 分布式系统设计模式的应用

本段深入探讨了分布式系统设计模式的应用，特别是Command and Query Responsibility Segregation (CQRS)和Two-Phase Commit (2PC)模式。CQRS通过分离读写操作来提高系统的可伸缩性和安全性，而2PC是一种事务性方法，侧重于中央命令但按类型和完成阶段处理分区。此外，还介绍了Saga模式，它是一种不使用中央控制器的同步模式，而是在微服务系统之间通过事件总线进行通信。这些模式各有优缺点，适用于不同的应用场景，如数据密集型应用、高风险交易和分布式系统。

25:08

🎓 分布式系统设计的总结

最后一部分总结了分布式系统设计的要点，强调了使用MapReduce和NoSQL平台来开发能够处理大数据和流处理的强系统。通过介绍不同类型的分布式系统设计模式，本讲座旨在提供如何开发可扩展系统的见解，并展示了大型公司如何开发运行在不同服务器上的应用程序，以及这些服务器如何相互通信。

Keywords

💡分布式系统

分布式系统是由多台计算机组成的系统，它们协同工作，对外表现为一个单一的系统。在视频脚本中，分布式系统被提及为能够处理大量数据和请求的关键技术，使得应用程序如在线商店和社交网络站点能够实现高可扩展性。

💡可扩展性

可扩展性指的是系统能够适应不断增长的工作负载或数据量的能力。在视频脚本中，可扩展性是分布式系统的一个重要优势，它允许系统通过增加更多的服务器或节点来处理更大的数据量，而不会影响系统的性能。

💡MapReduce

MapReduce是一种编程模型，由Google开发，用于处理和生成大型数据集。它通过将大数据处理任务分解为Map（映射）和Reduce（归约）两个阶段，使得处理过程更加高效。

💡容错性

容错性是指系统在部分组件失败时仍能继续运行的能力。在分布式系统中，容错性非常重要，因为系统中的单个机器可能会独立故障，而不影响整个系统的运行。

💡低延迟

低延迟是指系统响应用户请求或处理数据的时间非常短。在分布式系统中，通过在多个地理位置部署节点，可以使用户请求快速到达最近的节点，从而减少等待时间，提高用户体验。

💡并行计算

并行计算是指同时使用多个处理器或计算机来解决计算问题的过程。在分布式系统中，通过将复杂问题分解成小块，分配给多个处理器同时处理，可以显著提高计算效率。

💡状态无关和状态有关联

状态无关（Stateless）系统不保存任何会话信息或用户请求的历史，每个请求都是独立的。状态有关联（Stateful）系统则保存会话信息或状态，能够根据之前的交互来处理当前的请求。

💡Raft

Raft是一种用于管理分布式系统日志复制和状态机复制的一致性算法。它通过选举一个领导者（Leader）来协调其他节点（Follower和Candidate），确保所有节点的状态保持一致。

💡设计模式

设计模式是在特定上下文中解决常见问题的一套标准解决方案。在分布式系统中，设计模式提供了一种构建系统的方法，使得不同节点能够有效地通信和协作。

💡NoSQL数据库

NoSQL数据库是一种非关系型数据库，它不遵循传统的关系型数据库的结构，如行和列。NoSQL数据库特别适合处理大规模、非结构化或半结构化的数据，并且通常用于分布式系统中。

💡CQRS

CQRS（Command Query Responsibility Segregation）是一种架构模式，它将读取（查询）和写入（命令）操作分离，以提高系统的可扩展性和性能。这种模式通过分开处理读取和写入请求，减少了系统的复杂性，并提高了数据处理的效率。

Highlights

分布式系统使得开发可扩展的应用程序变得更加容易。

现代软件应用程序的数据和文件不断增长，需要大量存储空间。

许多公司使用复杂的分布式系统来处理多种类型的请求和存储需求。

分布式系统框架类似于许多计算机的集合，它们可以独立工作，并且相互连接，就像在单个计算机中工作一样。

分布式系统中的机器可以共享和同时运行相同的状态，并且可以独立故障而不影响整个系统。

分布式系统虽然复杂且难以部署和维护，但性能上有许多优势，如可扩展性、容错性、成本效益、低延迟、高效性和并行计算。

MapReduce是Google开发的一个框架，用于高效处理大量数据。

MapReduce使用宇宙服务器进行数据映射管理和分发，提供用户命令执行过程中底层进程的抽象。

MapReduce工作流程包括分区、映射中间文件、归约和聚合。

无状态和有状态系统是分布式系统中非常重要的概念。

Raft协议建立了复制状态机的内容和相关的复制日志，支持多轮连续共识。

分布式系统设计模式提供了构建适合特定用例的系统的方法，它们是允许我们利用现有知识而不必从头开始构建系统的构建块。

分布式系统设计模式分为对象通信、安全性和事件驱动三类。

CQRS（命令查询职责分离）模式专注于将分布式系统的读写操作分离，提高可扩展性和安全性。

两阶段提交（2PC）是一种事务型方法，依赖于中央指挥，但分区根据其类型和完成阶段进行处理。

Saga模式是一种不使用中央控制器的同步模式，服务之间通过事件总线进行通信。

分布式系统设计框架或并行计算框架使用MapReduce并考虑NoSQL平台。

AWS在许多功能中使用基于Saga的设计，如Step Functions和Lambda函数。

本讲座旨在提供如何在分布式设计框架中开发强大的可扩展系统的想法。

Transcripts

good day to everyone today our topic

will be distributed systems

as part of our discussion and lecture

for systems analysis and design and

implementation so our discussion for for

distributed systems

um considering your design could

possibly and should possibly be a

workable

for distributed systems

so we're going to discuss in here what

are distributed systems

okay so we as you can see in our

module here distributed systems makes it

easier

to develop scalable applications

and it is because nowadays more of

software applications

are growing

its data and data file and it requires a

large storage because data that it

accumulates every day are increasing in

exponentially and many companies uses

complex distributed systems

to handle many types of requests

and storage requirement

and that's the reason why we can see

that most of the applications that we

use nowadays especially those online

shops and social networking sites are

fully scalable it is because

their platform are based on distributed

systems framework

which is like collection of many

computers

which means their systems are enabled to

work

by of any servers and they are

interconnected to each other as if it is

working in a single computer

and in distributed systems

there are collections of share

and the same state

and operate concurrently okay or

simultaneously and these machines can

also fail independently without

affecting the entire system and that is

the reason why distributed system is one

of the framework which have been used by

many companies now

actually this type of framework or

distributed systems is quite complex and

it is difficult to deploy and maintain

but the performance has a lot of

benefits like scaling modular growth

full tolerance

and it is also cost effective

and it has low latency

efficient

and you can do parallel

um Computing so these are some of the

um known benefits

of distributed systems

okay so we can discuss it one by one

um

scaling so it means that

um your applications are scalable or it

is working through different platforms

okay and it allows you to do horizontal

communication with different types of

systems

modular growth so there's almost no cap

on how much you can scale and it is full

tolerance

it means that if one machine or a

malfunction the other machine will not

be affected and it's cost effective so

the initial cost is higher than the

traditional systems but because their

capacity to scale they quickly become

cost more cost effective

and low latency you can have a node in

multiple locations so traffic will hit

the closest node and an efficiency

distributed systems break complex data

into smaller bases

and parallelism distributed systems can

be designed for parallelism where

multiple processors divide up a complex

problem into smaller chunks

so in distributed systems failure so

these are some of the common failure

that you may encounter if you try to

develop a system which is like a

distributed system

okay so we all know that system failure

may occur anytime okay and it is usually

the result in the loss of content of

primary memory but the secondary memory

secondary Memory Remains safe so that's

what's uh advantage in terms of a

handling system failure in distributed

systems whenever there's a system

failure the process fails to perform the

execution and the system very good or

freeze communication needle failure so

it occurs as a result of communication

link failures or shifting of notes

and there is also another failure it's

possible failure in distributed systems

which is secondary storage failure that

occurs when the information are stored

on the secondary storage device is

inaccessible

okay and it can be caused by many things

like crashing dirt on your devices and

carry the errors

how about method failures so it's

usually a halt the distributed system

and make it an unavailable to perform

any execution at all so it may enter a

deadlock state or do protective

violations during the method failures

so what are the fundamentals of

distributed system

so in here we are going to discuss some

of the lists of our fundamental

components of

distributed system okay first is

mapreduce what is mapreduce it is a

framework developed by Google to handle

large amounts of data in an efficient

manner so if you're trying to develop a

system which is like for example an

online shop or a social like a social

networking sites or some kind of

automation okay or reservation sites so

you you expect that in the future it is

going to collect lots of data or require

you to hold large amount of data and

with that mapreduce is one of the

framework that can be used as part of

being distributed systems okay so we

encourage the development of new systems

like application of produce for

distributed systems in your

system's design

so mapreduce uses Universe servers for

data map management and distribution and

the framework provides an abstraction to

underlying process happening during the

execution of user command so mapreduce

as it is being applied for all big data

applications

include full tolerance partitioning data

and aggregate data so it allows user to

focus on High level logic of their

programs while trusting the framework to

smoothly continue the process so in this

diagram we're showing the map reduce

workflow so first is partitioning and

then map intermediate files reduce and

aggregate

so what is partitioning so in

partitioning the data is usually in the

form of a big chunk so just like the big

data and then

partitioning it into smaller portions

making it more manageable pieces okay

that can be handled

um through a map and then map or map

worker receives the data in the form of

key value pair so we discussed in

our discussion that the most of uh no

SQL

database platform it could also be key

value pair so if we try to develop a

distributed systems then we are

considering we have to consider no SQL

platform for our database so this data

is processed by the map worker and

according to the user defined

malfunction to generate intermediate key

value pair

and then intermediate files the data is

partitioned into our partition with r

being the numerous reduced workers so

these files are buffered in the memory

until the primary load for forwards to

reduce workers and then reduce so what

is reduced as soon as the reduced

workers get the data stored in the

buffer they sort it accordingly and

group data with the same key okay so

that's really a good way to manage your

data storage and that's why distributed

system is really well encouraged for

um

web applications that could handle big

data

and it is the future of storage

aggregate the primary node is notified

when the reduced workers are done with

their task and in the end the sorted

data is aggregated together and our

output files are generated for the user

so you see how systematic it is

now let's discuss another

um

another component of distributed system

which is stateless and stateful system

so stateless and stateful systems are

important

very important concept of distributed

systems

okay because a system can be stateless

or stateful so we say a stateless system

is the one that maintains no state of

past event

okay and it executes based on the inputs

that we provide to it how about stateful

systems these are responsible for

maintaining and mutating a state so

those are stateful and stateless

and then another component of

distributed system is raft so it's

stabbed ref establishes the content of a

replicated State machine and Associated

replicated log of plants so as first

class citizens and support

multiple consecutive rounds of consensus

by default it requires a set of nodes

that form a consensus group or rough

clusters

so the following can be one of these

states leader follower and candidate so

in this diagram you can see the

different draft

okay

is the implementation of wrap

okay so now let's discuss distributed

systems design patterns

so what are design patterns it gives us

a way to build systems that fit

particular use cases so they are like

building blocks that allows us to pull

from existing knowledge rather than

start even systems from scratch so they

also create a set of standard models for

system design that helps other

developers see how their projects can

enter interface with the system

okay so these are

some of the examples so creational

design patterns provide Baseline when

building new objects so structural

patterns Define the overall structure of

a solution and behavioral patterns on

the other hand describe objects and how

they communicate with each other

okay so distributed system design

patterns outline a software architecture

of how different nodes communicate with

each other

so most of distributed system patterns

fall into one of the three categories

below object communication so that's one

of the types of distributed

stem design pattern another is security

and then

another is event driven so for object

communication it describes the messaging

protocol and permissions for different

components of system and security it

handles confidentiality Integrity

availability that concerns to ensure the

system is secure for authorized

and then event driven it describes the

production deduction consumption and

response to system okay so if you uh try

to design your system

um and consider

um having a a type of distributed system

for your development so you have to find

or you have to think of

um which type of distributed design

pattern that is applicable for your case

it could be object communication

security and event driven and also

considering your database applications

it has to start with what type of

applications you would like to

develop it's because you know

um no SQL databases May differ from one

another there are many types okay four

or five types of

um

no SQL databases and the choice of type

that you will consider will depend on

what type of data you have and what type

of information you would like to start

as

um no SQL systems is very concerned with

data storage so you really need to think

of what is the best fit

type of no SQL and considering that

um

a type of no SQL

choosing a type of design pattern for

distributed system is also one of

crucial considerations that you have to

do okay so those are Interlink each

other

okay

so now let's continue our discussion and

we're going to discuss

um

the top five uh distributed system

design patterns so these are the top

five

commonly used design patterns so these

are tried and tested way of building

system that could fit in a particular

case

uh they are abstract way of structuring

your

system or designing your system or the

structure of your system so most design

patterns of development updated over the

years and many different Developers

are starting

very efficient okay

design patterns are building blocks that

allow programmers to pull from existing

knowledge rather than starting from

scratch with every system so that is now

the new way of systems development okay

the old ways of

development like starting first from

scratch is already gone and in this new

era in the Ford Industrial Revolution

developmental system

encourage code reuse or reusing code

which have been used in other

applications

that's why it is also encouraged in

distributed systems

so these design patterns

also create a set of standard models for

systems design that help other

developers see how their projects can

interface with a given system

so there are what we call creational

Design patterns

that provide a baseline when building a

new object so structural patterns Define

the overall structure of a solution

while on the other hand behavioral

patterns describe objects and how they

communicate with each other okay so as

we can see

these different patterns have

each specializations okay in terms of

Designing different

um components okay and different aspects

of your system distributed systems

design patterns or Design This is used

when developing Distributing systems and

essentially collections of computers and

data centers that act as one computer

for the end user and that is how we are

feeling it right now like you know the

social networker side AWS

um it feels like we're using only one

computer but you know these computers

are located in many different places

around the world

so just like um Facebook it has

it has many it has many data centers

over 100 over 200 data centers all

around the world and they can they can

make us feel that as if we're using a

single system it's because of this

framework okay the distributed system

and this distributed design patterns

outline a software architecture for how

the different nodes communicate with

each other which nodes handle its task

and flow for different tasks and that's

the reason why distributed system is

really strongly encouraged to be one of

your framework in systems development

and this pattern are widely used when

designing distributed architecture those

patterns that we have discussed the

behavioral pattern the distributed

systems design pattern

creational design okay these patterns

are encouraged

okay and as I've said these are used for

large-scale computing or large scale

um

systems web applications like cloud

computing and microservice software

systems

so these are the types of distributed

design patterns

okay here object communication it

describes

the messaging protocol and permission

ensure that system is secured from an

authorized access okay another types is

event driven so you can choose with

which type of Distributing system you're

going to consider based on use case Okay

based on your different cases or on the

type of system that you're going to

develop event driven it it has patterns

that describe the production detection

consumption and response to system

events

okay so another component that is

related to our

okay here

so these are the top five distributed

systems command and query

responsibility segregation or cqrs which

focus on separating the read and write

operations for distributed systems so

this is another

um one of the top five distributed

system pattern

this is one of the mostly used uh

distributed system pattern what we call

cqrs

so it increases the scalability and

security and this model uses commands to

write data with persistent storage and

queries to locate and fetch data okay

it is handled by Command Center which

receives requests from users and the

command centered infectious the data and

makes any necessary modification saves

the data and notifies the read service

so the read Service then updates the

read model to show the change to the

user

what are the advantages of this type of

pattern or cqrs it reduces systems

complexity by delegating tasks it

enforces a clear separation between

business logic and validation it helps

categorize process by their job

it reduces the number of unexpected

changes to share data and reduces the

number of entities that have modifying

access to data how about disadvantages

it requires constant back and forth

communication between commands and read

models can cause increased latency when

sending High throughput queries and no

means to communicate between service

process so

how about the use case

okay this is our use case related to

secure s secure s is best for data

intensive applications just like SQL or

non-sql database management system it's

also helpful for data heavy microservice

architecture and it's great for handling

stateful applications because read

writer reader a writer reader

distinction helps with immutable States

okay

so in another type or another

another

um distributed system pattern

uh next to cqrs okay here is secure as

okay yes okay here is two phase commit

or two PC

so it is similar to cqrs and its

transactional approach and Reliance on

Central Command but partitions are

processed by their type and what stage

of completion they're in so the two

phases are prepared and complete so

that's what we call two phase commit all

services in two PC systems are locked by

default and meaning they cannot send

data so while Lock Service complete the

prepare stage so they're ready to send

once unlocked and the coordinator

unlocked service one by one and request

its data

the service is not ready to submit its

data then the coordinator moves on to

another service and once all prepared

data has been sent all services unlocked

to awake new tasks from the coordinator

so these are the two advantages are the

advantages of two PCS consistent

resistant to error due to lack of

concurrent requests scalable and can

handle big data pools as easily as it

can handle data from single

machine and allows for isolation and

data sharing at the same time

and these are the disadvantages

non-fault tolerant prone to bottleneck

and blocking due to synchronous nature

excuse

requires more resources than other

design patterns

okay

so to PC is best for distributed systems

that deal with high high stakes

transaction

that favor accuracy over resource

efficiency and it's resistant to error

and easy to track mistakes when they

occur even as scale so another type of

um distributed system design pattern is

Saga okay

it is a synchronous pattern that does

not use a central controller and instead

communicates entirely between services

so this overcomes some of these

advantages of previously covered

synchronous pattern

Saga uses event bars to allow services

to communicate with each other in a

micro service systems and the bus sends

and receives requests between services

and each participating service creates a

local transaction so the participating

Services then each emit an event of

other services to receive and other

services all listen for events and the

first service to receive the event will

perform the required action so you can

see now

um

uh conceptually the flow of how Saga is

working and if service fails to complete

the action it's the same to other

devices

and the structure of saga is similar to

the PC design in that services are

cycled if one cannot complete task

however Saga removes the center control

element together manage the flow and

reduce the number of back and forth

communication

okay so these are the advantages is

individual service can handle much

longer transaction and great for

distributed system due to

decentralization

and reduces bottleneck

um like peer-to-peer communication

between each services

disadvantages asynchronous autonomy

makes it difficult to track with

services

which services are doing individual

tasks and difficult to debug true to

complex orchestration and less service

isolation in the previous pattern

okay so just like in AWS so AWS uses

Saga based design in many functions like

step and Lambda function

okay

so that's all for that's all for our

lecture regarding distributed systems

design and uh I hope that this lecture

has given you

um an idea of how to develop

um

systems design on how how are you going

to consider

um designing a systems

in a distributed design framework or

distributed systems design framework or

parallel Computing framework that uses

um

mapreduce and also considering no SQL

platform so I hope that this lecture

have given you

um the chance to connect the dots on how

really this big companies were able to

develop

um applications which are running on

different servers and how each of these

servers are communicating with each

other so thank you very much and I hope

that this lecture has given an idea on

how to further develop

strong systems scalable systems which

could uh which could be able to handle a

big data and even streaming system

thank you very much