Welcome to the section
on AWS integration and messaging.
So this section is kinda cool because we're going
to see how we can orchestrate stuff
between our different services using middleware.
And so in this section basically,
when we start to deploy multiple applications,
they will inevitably have to communicate with one another.
Okay, your services need to share information, share data.
And so there will be two patterns
of application communication out there.
There's going to be a synchronous communication
so your application will be directly connecting
to another application of yours.
And so for example we have, you know,
we sell something online, and we have a buying service,
and when something is bought, we need
to talk to the shipping service
to send that item that was just bought.
As you can see here,
my buying service and my shipping service,
they're directly connected to one another,
so there is some synchronous communication happening.
My buying service says, hey something happened,
shipping service, do it, okay?
The other type of integration and pattern
is going to be asynchronous or event based.
And so there will be a middleware called
a queue or called something else,
basically that will connect your applications.
So this time the buying service says,
hey, someone bought something,
and so I'm gonna put that into a queue, and that's it.
And the shipping service says, hey queue,
is there something that got bought recently?
And the queue will return that element
and the shipping service can do whatever it wants.
So as you can see here, the buying service
and the shipping service are not directly connected.
There is a queue in between.
And so because they don't directly talk
to one another, this is asynchronous.
Now, synchronous between applications can be
a little bit problematic sometimes,
because if one service overwhelms the other
because there is a sudden spike of purchases or whatever,
it could be a big problem right.
So if you need to encode, for example
we have a video encoding service,
and we need to encode 1,000 videos but usually it's 10.
Well, our encoding service is going to be overwhelmed
and we're going to have outages.
So, when you have these sudden spikes of traffic
or you can't predict anything,
then it's usually better to decouple your application
and have the decoupling layer scale for you.
So in that case that could be SQS for a queue model,
that could be SNS for a pub/sub model,
and that could be Kinesis, if you do real time streaming
and you have like big data.
So we'll learn all about those in this section.
And what we'll learn is that now,
using these three things, our services
can scale independently from SQS, SNS, and Kinesis.
And these three things scale as well really, really, well.
So that's the whole paradigm.
And so we're gonna get started with learning
these three technologies in this lecture.
So, see you in the next lecture.