Welcome to Solving with
AWS Solutions, your deep dive
into reference architectures
built by AWS that are ready to
deploy instantly in the cloud.
I'm Fabian and I'm joined today
by Eric from the
AWS Solutions team.
Today, we're going to be
talking about Machine to
Cloud Connectivity Framework.
This solution helps you collect
industrial telemetry data and
securely send it to
the AWS cloud.
From there, you can unlock a
wide array of use cases
like visualization,
analytics and
machine learning.
Let's take a look.
Let's take a look
at the solution.
Yeah, so here we've got the
landing page for the solution.
And if you scroll down,
we've got some links for you.
So down here, we've got a link
to the implementation guide,
which is gives you some
instructions on how to
deploy the solution.
OK.
We've got a link to the Cloud
Formation template will allow
you to deploy the solution with
one click right
into your account.
Mm-Hmm.
We've got a link to the
source code, which is
everything is open source
available on GitHub.
And here we have
the architecture diagram.
And if you see here we have an
on premises side and an
AWS club side.
Yeah, there's a lot going on
the on premise side.
So yeah, so let's take a look.
So right here on the left
hand side, this is represents
your actual factory equipment.
This is the machine data that
you want to collect and bring
it into the AWS cloud and what
you see here in your industrial
gateway that has
green grass running.
We've got a series
of collectors, so a collector
is basically three things.
So we've got a
collector Lambda function,
stream manager stream and then
we've got a publisher.
So the publishers, how do we
actually get the data
into the cloud, collector is
how we get the data off
the machine, and the stream
manager is what how the data
gets from the collecter
to the publisher.
Those three together, we call
that a connection
in the solution.
So we've got
three connections here.
We've got one for
OPC-DA protocol, got one with
OPC-UA protocol and we've got
here an example you can bring
your own protocol if you have
for using a
different protocol.
For OPC-DA, we've deployed
Lambda function to serve as a
collector for you.
For OPC-UA, we're using the
SiteWise Collector.
OK.
And then once you've got your
connection set up and running,
it's just about getting the
data into the AWS cloud.
So once you've got the data,
the connection running, it gets
sent to your destination.
So we support
three destinations today.
We support IoT Core,
AWS IoT SiteWise.
And then we also send data to a
Kinesis Data Stream that you
can then use to send the data
anywhere you want.
Can you show me the console?
Yeah.
So let's take a look here.
So here's the console for the
solution you see here.
I've got three
connection set up.
Two of them are running.
I've got an OPC-UA connection
and an
OPC-DA connection running.
So let's take a look at the
data that's actually
coming into AWS.
So let's go over here.
This is the IoT core console,
and I'm looking here at the the
test client to look at
the IoT topic.
So right here we can see some
simulated data coming in.
This is our OPC-UA connection.
And then if we look here,
I've also got the same similar
simulation data coming in for
our OPC-DA connection.
If you take a look back here at
the at the console again,
we can take a look at what it
looks like to actually create
one of these connections.
Let's go over here.
Yep, and we're going to give
our connection a name how you
want that connection to show up
in the console.
And then we're going to model
our factory a little bit.
We're going to give the name of
the site area process and then
ultimately the machine name
that we want to
collect data for.
And then here's where we
have our destinations.
So you can select all three,
you can select just one.
It's really up to you.
These are the three
destinations that
I mentioned earlier.
And then here for OPC-DA,
we've got a couple of options
that you have to fill in.
Iterations is the amount of
data points that you want to
collect before you actually
publish a message that gets
sent to AWS.
Okay.
Makes sense.
And the time interval is in
between those iterations.
How long do you want us to wait
?
So as an example, if I want to
send five data points,
my iteration would be five.
And if I have a time interval
of one, that means that the
solution is going to actually
publish five messages
every one, every five seconds.
The server name this is just
the name of the OPC server that
you have running and the IP
address of the machine on which
that server is running.
And then you want to just have
a list of the tags that you
want to collect.
So, for instance, a tag is just
basically the name of a machine
data attribute they
want to collect.
So you can give a wild card to
collect a bunch of them, or you
can give an explicit list.
And then just really quickly,
let's look at OPC-UA.
Mm-Hmm.
So OPC-UA similarly that we're
going to collect the server
name IP address,
optionally a port, but you'll
see here that we don't have
time interval or iterations.
And that's because with the OPC-
UA protocol, we can actually
collect data as
it's published, whereas with
the OPC-DA protocol,
we actually have to pull
for the messages.
So once you create that
connection and go ahead
and create, then that Lambda
function to collect the
function will be deployed in
your Greengrass environment and
it should be started and you're
going to start
collecting the data.
This is great.
Thank you for walking
me through this.
My pleasure.
Thanks for joining us as we
explored the Machine to
Cloud Connectivity Framework.
Check out this solution and
many more on the
AWS Solutions website.
See you soon!