- [Mallory] Welcome to an Amazon S3 on Outposts demo.
I'm Mallory Gershenfeld, a Senior Product Manager
for S3 on Outposts, and today I'll be showing
how to use S3 on Outposts for local data processing
with an example
of how to help improve your operations
with computer vision at the edge with AWS Panorama.
AWS Panorama is a service that brings computer vision
to your on-premise camera network.
You install the Panorama appliance
or compatible device in your data center, register it,
and you can deploy your computer vision applications
from the cloud.
On today's session
we'll show how to deploy locally right on your AWS Outpost.
Panorama works with your existing realtime
streaming protocol network cameras.
The appliance runs secure computer vision applications
from either AWS partners
or that you build yourself with a Panorama Application SDK.
In a moment, we'll see how Panorama can read
and write from the local S3 on Outposts bucket
and run a self-contained computer vision application
at the edge.
We'll see Panorama does inferences
on images generated from your video feeds.
S3 on Outposts can be used
to stage application code, models,
and configuration files for deployment
to an AWS Panorama appliance.
For example, you can receive site safety alerts
that monitor off-limit areas at an industrial site.
When your Panorama model detects a potentially
unsafe situation through an inference image
it can upload the image to your S3
on Outposts bucket and send a notification
to Amazon's simple notification service, Amazon SNS,
so key recipients can take corrective action.
Today we're gonna analyze a sample town center video
from the published samples available
in GitHub using the AWS Panorama Simulator SDK.
Note, we won't use a Panorama device
but it would follow the same deployment path
from the device to the Outpost.
The services we'll use today include AWS Outposts,
S3 on Outposts, AWS Panorama,
and the Panorama SDK Simulator,
and an EC2 instance running on the Outpost.
Next, we'll go over to the console
and bring up our Outpost.
From the search bar,
we'll look for Outposts.
And for today's demo, we'll be running this
on an Outpost ending in 5E.
You can manage your S3 on Outposts capacity
from the actions button.
So we'll hit Actions, Manage S3 buckets.
For this demo, we have a sample bucket already created
that we want to store our model output in.
When we click in
a key concept is that Outpost access point ARN,
which are named network endpoints
with a specific access policy that describes
how data can be accessed using that endpoint.
Access points simplify managing data access
at scale for shared data assets in S3 on Outposts.
Access point ARNs are required for all object operations
on Outposts instead of bucket name.
So here we'll click the Copy ARN.
Next, we're going to launch an instance
from EC2 to run our inference simulator.
So we'll go back to the AWS Outposts main page
and we see we have 13 instances already running.
We'll click into that and you'll see that'll bring us
up to EC2 homepage
and it's filtering to all the instances already running
on this Outpost.
We'll go ahead and search for our demo instance.
We'll take note of our IP addresses
and we'll also take note of our key pair name
and make sure that we have it downloaded
when we first launch the instance.
Second, we'll ensure that EC2 has the correct IAM policy.
So we'll go under IAM Role and click the SSM Role.
The two permissions we're looking for are
S3 on Outposts Full Access.
So this will enable us to write
and read the inference images from the EC2 instance
to our S3 on Outposts bucket and SSM Full Access so that
we can spin off a Jupyter Notebook for the model review.
Now that we've confirmed
our EC2 has the correct permissions,
we'll go back to our EC2 Management Console
and we'll connect.
To spin up your notebook, we'll use an SSH client.
In this case, take note
that your pem key will have to be modified
if you're using a tool like PuTTY to be PuTTY enabled, ppk.
As mentioned earlier,
AWS Panorama has a published GitHub package
that we'll be using
in a test utility environment that has all the step
by step instructions on how you'll be SSHing
and how you'll be bringing up your notebook
on a particular port of your choosing.
Here we'll use PuTTY for this particular example,
and after I've already SSHed in and I'm ready
to spin up my notebook, I'll use Jupyter Lab command.
Here, after cloning the GitHub examples,
we'll be using the People Counter example that's published.
You'll see this says People Counter Tutorial Notebook.
This notebook has starter code
and videos to get you started working with Panorama.
We'll install the IDE of our choice, in this case Jupyter
and make sure we have the needed packages
in our environment
before spinning up the notebook.
Here, we'll be using the familiar Boto3
and SageMaker packages and Python, the AWS SDK for Python.
It's the same S3 client as in region that you're importing.
And here we see we're using the People Counter app
and here we see we'll be using that town center video
to create the inferenced images from.
So we'll import our needed packages
and now that we're ready to test the app
and start coding, how are we going to inference the images?
You'll see here under categories, we have a variety
of classifications, person, bicycle, car,
that we're looking for the model
to detect in the image and label as such.
Next, in this last step
you'll see the Send to S3 and you'll see
that this is the access point ARN that we copied
from the S3 on Outposts console screen.
We'll go ahead and run our model.
Now, we see that the model has successfully run
the computer vision model
and labeled all the categories that we asked
and it's looping through the pictures.
So we see the bench, the person, and the bicycle
with the confidence interval that it's been labeled as such.
From here, you could package that into an app
and deploy it back on your Panorama compliant device.
You can store this notebook
and all other app files in your S3 on Outposts bucket.
So for our final step, we'll go ahead
and list the objects that we have just used in the model.
So here we're using the same S3 Boto client
and we'll use the list the object V2
to list all items (computer chimes)
in that bucket.
And now we see all of the images that we exported
from the computer vision model in our local S3
on Outposts bucket using the familiar Boto3 client.
And that concludes our demo.
Before Outposts, you've been able to do computer
vision models using S3 buckets and region.
However, we've heard the customer need to do this locally
at the edge for compliance reasons
or scenarios where customers are generating a lot
of data and want to process and filter locally
before sending it back to the cloud for long-term storage.
Now architecting with S3 on Outposts,
you can process data locally to support such use cases.
Thanks for watching.