In this section, we are going to do hands on up inventory with Microsoft's architecture using Amazon
event, which is aqueous and lambda.
So we will see how to decouple microservices with events using the Amazon event bridge.
Let's directly look at the internal architecture for our Hands-On Update.
We use the publisher Scribe Panel pattern.
You can see the image on the slide.
Basically we are following the ecommerce architecture and use case is basket checkout event one user
checkout to basket.
This will trigger an event to event page and consume from the ordering microservices.
So there is a couple of microservices which implement ecommerce modules over the product basket and
ordering microservices.
We will use a lambda service as a microservice and use power of lambda function.
Let me explain.
Basket Lambda Microservices Basket Microservices triggers to event driven use case which is the checkout
basket one checkout basket.
This will publish and create event to service event bus, which is the Amazon event page.
And this is the asynchronous communication we'll have by the basket Lambda Microservices and Amazon
event page and consumed by the ordering microservices over the A case.
So Amazon event pitch asynchronous communication held by the soulless event pass and we will create
the rules and target definitions for Amazon event page from the basket of microservices.
That means we will develop basket microservices one publishing checkout message to Amazon event page
with using the SDK libraries for development purpose.
So if we look at the CSS and ordering Lambda Microservices after publishing checkout event two event
which this event will consume by the ordering path event sent to event to Amazon in order to gain power
of to a queue.
After that ordering Lambda Microservices will consume this event with polling invocations.
That means we will use a one source mapping communication type here when consuming events, ordering
lambda microservices and pulling requests and get event from the queue after consuming the event from
the queue or the Lambda Microservices process, the event with the creating order record into its Dynamo
DB table.
So ordering Lambda Microservice perform all these operations, we developing Lambda functions and using
the SDK libraries so we will develop together and step by step in this video.
Okay.
So if you look at the communication patterns, we have also followed the communication pattern and best
practices when designing soulless microservice communication for synchronous asynchronous and also event
source mapping.
We are using the Amazon API gateway Amazon Event Bridge as an event pass and also Amazon is using as
a queue service.
So we will use API gateway for restful API driven development and synchronous event sources.
We will use event bridge for event driven asynchronous communication between microservices.
We will use case for decoupled microservices and process events asynchronously using to use.
So in this section we will learn how to publish subscribe pattern apply using with Amazon event page
and space that enables asynchronous message communication.
When we link distributed microservice architectures, there is no debt that we implement in architectural
networks.
We have two main steps.
The first step is create infrastructure on the cloud and the second step is the actual lambda function
code and interacting with the squares, event bridge and so on using the SDK libraries.
So we will start with the first step, which is to create this infrastructure on a lot.
But before that let's start to remember event driven microservice architectures.