Intro to AWS IoT Greengrass - Edge Computing

to the meetup today we're going to cover the second part of our aws iot overview diving into aws iot green grass and this is a part of the meetup series of the aws meetup group a user group with aws based out of the denver area and just a quick round of introductions i am kevin tin co-organizer of the meetup i'm a cloud application architect and practice lead at worldwide technology as well as an aws community builder uh my my counterpart in the meetup austin lovelace the founder of the meetup full stack developer and devops engineer at stuzzo and an aws community hero and so to jump into the agenda for today uh first we'll take a look at the overview of the service the green grass service that is we'll get into how to set up a device in this case a raspberry pi as well as the green grass service itself then we'll jump back into the green grass core setup on the raspberry pi then we'll start looking a bit at how to use the green grass core unit deploying a lambda out to the raspberry pi itself a lot of the constructs within green grass are based upon message queuing on on-premises now within aws and we'll get into that a little bit more so we'll kind of dive into what are the constructs of that messes queuing using the mqtt service and and how to use it setting up subscriptions stuff of that nature then we'll dive into kind of the difference in green grass of on-demand versus long-lived lambdas again getting into green grass services and connecting devices how to configure devices then finally we'll get into device shadows and a demo of device shadows and so to just briefly cover the iot green grass service uh green grass provides an extension of aws services to on-premises devices and so some examples of this uh not not an extensive list but including some examples would be lambda machine learning message queuing secrets management and data streaming so the green graph service itself is optimized for iot or internet of things use cases also the provisioning and deployment capabilities are a big plus to the service itself the ability to provide over the year updates to your greengrass group offline operating capabilities and so the ability to have aws services on premises even when internet connectivity has gone down for example as well as the built-in security of the service itself and so i'll go ahead and jump out of the full screen mode here as i'm going to be jumping back and forth between windows uh pretty frequently here so first of all we'll get into the device setup and so firstly and i won't go into this explicitly as i've done this ahead of time but green grass can run on a variety of platforms arm x86 for example and so for this i'm using raspberry pi for my green grass node and i'll just be interacting with it from my laptop across the local area network and so to get started with this uh you will need a raspberry pi obviously you'll need to format the sd card of the raspberry pi and then you'll need to flash it with some sort of flashing software so i use sd card formatter on my mac for the formatting of the card and then the etcher software to go ahead and put the raspbian buster zip image on there so just a quick overview of those and you can download these pretty easily and so the sd card formatter very simple application and then with etcher with this you download the the zip file in this case the 2020 213 raspbian buster zip image go ahead and select the file from there if you have a card in inserted into your card reader on your computer you can select the target there and go ahead and flash it it also provides the ability to flash from a url as well and then also finally the ability to continue to clone devices uh if you want to create say multiple sd cards with the same image and so after you've gone through this the uh the flashing of the sd card with the raspbian buster image go ahead and insert that into your raspberry pi boot the device up and go through the config and so the config on the raspberry pi you will need a keyboard a mouse and a display connected and it goes through you know selecting the default language for the operating system setting up wi-fi etc okay and so once you uh get this on the network and enable ssh you'll be able to interact with it and so at this point let's go ahead and say that you've configured your raspberry pi to get on the network and you are getting into enabling ssh in order to do that on the device you'll need to go into the raspy config and so we can emulate this let's see so you'll need to sudo raspy config here that pulls up a window that looks like this on the raspberry pi and if you want to get into for example changing your host name you can do that here but what you will have to do with the keyboard mouse and display still hooked into the raspberry pi is enable ssh and so to do that you'll have to get into the interfacing options and enable ssh i've already done this and so i'll just kind of breeze through this okay and so additionally you can go in and change the hostname of your device as i mentioned i use gg which is short for green grass and i'll use that abbreviation pretty frequently here and so in order to kind of confirm that the command hostname will pull back the hostname gigi as expected and then also you will need to get the ip address of your raspberry pi and so in order to do that it's as simple as the same hostname command but dash i for ip address and that gives me a 192 168 1.130 as well as the ip v6 address which we won't be using in this case after you do all of this you will need to reboot the device and these changes will take effect and then you'll be able to ssh into the device and so some basic setup that you'll have to go through in order to set up the green grass raspberry pi is you'll have to add the default green grass core user and group so gg short abbreviation for green grass ggc that's abbreviation for green grass core so i've already done these steps um and so with that being the case i did want to just outline the setup that i went through so adding the user in the group it's also recommended that you harden the device with uh symbolic link protection sim link protection for short and so inside of the the etsy assist control dot d uh file uh the fs protected hard links equal one or true and fs protected sim links equal one or true uh should be set up and then you'll need to reboot after that uh after that the uh the memory limits need to be set up so going into the boot directory and then there's a command line dot txt file and then adding the memory c group uh underscore memory equal one to the end of that and again you'll need to reboot and if your system for the purposes of these examples does not have python 3.7 installed you'll want to also install that and additionally if you get into wanting to get into the streams management portion of green graphs you'll also want to go ahead and install the java 8 runtime that's not applicable for today's demonstration okay so now we get into some of the more fun stuff so you'll want to go ahead and get the required dependencies and so with that we've got these commands here to download to make a directory and download the dependency checker for green grass core and so with that being the case let's go ahead and pull this up here and we can pull the console down below and so with that being the case so we will go into cd home pi downloads let me make this a little bit bigger i'm sure that's hard to read let's see all right so here i've already created the directory for the dependency checker so here i can get into to that taking a look here the next trick is to go ahead and do a w get and download the dependency checker and then unzip it again i've already done this so then you can just go ahead and get into that directory that came from the zip file so let's go ahead and get into here and so this pulls back a bunch of different uh files that came out of the zip itself um so with that being the case i'll skip to this last step just to show you what the dependency check looks like and so here um it goes through and it checks the kernel architecture to ensure that that is something that it can operate on the kernel version um it also gets into the the various um the various uh commands and software packages that you have installed so for the purposes of our demo python 3.7 is the most pertinent as well as you know something such as like wget to download the software tar to go ahead and be able to unpackage archives things of that nature and again it checks the security so where we went ahead and set up the hard link protection and sim link protection um it checks on that and then finally the default user and group uh it will check on that and so uh it does mention um python38 not being supported um then also it'll get into some other things like for example i mentioned java 8 not being there um it will mention that you're missing a few other things if you just go with this base set up here okay and so now to get into setting up the actual green graph service itself now we'll jump over to the aws portal and so once we go there we'll go ahead and create our green grass group this is basically the core management container for everything that we're going to do going forward and so to get into that let me go ahead and log into the console if you do not have multi-factor authentication set up for your account i would strongly recommend that you do so okay so inside of the console this is located within iot so iot core is a good way to get there looks like this is taking a few seconds let's go ahead and switch back over to the slides and take a look at the steps we're going to go through and so during this process we're going to go ahead and create the green grass group as well as the green grass core device i've already done these things but i wanted to spell these out as the steps that you want to take so for the purposes of this demo they have a new ui and so i've i've not gotten uh ultra familiar with it i i tend to operate just from the classic or v1 version of the ui and so you'll want to navigate into groups here so i've already created my group but uh to get into creating your group obviously you'll want to hit the create group button um there the just for most use cases just go ahead and create the default creation um we'll give this a name then after that we'll go into creating the green grass core uh that's the kind of the control of the the whole green grass group and you can have multiple course but in this case we're just going to have a single and the green grass core in this case is going to be the raspberry pi that we walk through the configuration for and so once we get into this we get into what will be done on your behalf and then the creation of the group itself so it walks through these steps that it tells you that it's going to walk through and then finally and this is incredibly important you'll want to download the resources here your your cert your certificates and this is uh incredibly critical in order to ensure the security of the green grass group itself and so jumping back into the slides i have a little screenshot here don't forget to grab the certs so with that being said jumping into the uh the next step here at this point what you'll want to do is go ahead and download the files um then you'll want to do a secure copy of the files over into the raspberry pi and so from the initial setup when we did the hostname dash i will you'll get the ip address and then also additionally there is a green grass core runtime and so that's easy enough to find for your um for your uh particular architecture so uh that's in this particular case um let's see here to copy over the um the certificates and the actual run time for green grass was the linux arm 6l 1.11 and so if you're running on a raspberry pi easy enough to to go out and find the download of that so fair enough with all that being said you can also go into the the the aws docs to to find uh your platform here so where i have the raspbian uh uh distribution for my raspberry pi i just went ahead and uh grabbed it from here so at that point uh you'll like as i mentioned want to go ahead and secure copy scp stands for secure copy this is available on mac and linux like operating systems with a windows operating system you'll want to use a utility such as putty and so going ahead and getting these uh securely copied over to your raspberry pi in the home slash pi directory uh will be what you'll want to do and then on the device itself you'll want to run these commands to to go ahead and extract the contents of your zip files into the root and then into a green grass folder and so get into here and into the home of the user so here we went ahead and uh this is where we uploaded the um the uh the the executable for green grass as well as the the certificates as well and so with that being the case the we've got the green grass directory here and so to get into the file system here we have a search directory a config directory the green grass core directory and the ota directory and so the search directory is of particular importance so let's go ahead and dive into that so after following the steps we would have these three certificate files from the zip that we downloaded from the the core device configuration and so that being said there's still a root certificate authority filed that you will need in order to get green grass to run now with that being the case get into that search directory inside of the green grass directory as i mentioned and just run the command sudo w get the root ca from the the aws path that's specified and so that you can find that as well from this choose root ca and so that's actually this file right here if i'm not mistaken so for most use cases you'll want to want to go ahead and use the root certificate authority one and so why all the business with the certs as i mentioned green grass is a security first kind of platform and so everything is basically secured using certificates so from a device standpoint that includes the green grass core device as well as iot devices that we will create here in just a little bit and so the next step here is to go ahead and start up the green grass daemon and so in order to do that we'll have to get into green grass ggc slash core so let's go ahead and start that up one more okay actually i went too far bear with me let's go ahead and just copy and paste here okay so here we've got the actual daemon itself and so to start it it's as simple as pseudo super user do is what that stands for green grass d the daemon itself and then start then you'll it'll output a process id i did this earlier we can do this again for sure and so since it's already running what this is going to do is stop the daemon and then restart it uh worth noting that if you restart the device that it's running on the daemon by default does not run itself and so you'll want to configure the device um to uh to start this up in a production scenario on device startup and so with that being the case we've got this process id that it outputs of 8123 and so if we want to dive in and take a look at just the process information on that we can use the the ps aux command and then use that process id that outputted and so here we can see that this is running it's not been running for long i just restarted it i think that's to be expected but we do have it running so that's very important so with that being said an instant title a happy dog we've uh we've got half the battle and so now the the what we want to get into is with the the the runtime itself going um we want to go ahead and actually get software running out on the green grass core node and so in order to do that uh the easiest way to deal with that is to to use the familiar lambda programming model and then deploy that out to our green grass device and so um i will say that um the a lot of our the examples coming out of this presentation are just coming out of the um the sdk and so the sdk comes for a variety of languages i'm using python in this case but no js java and c are available and so i've downloaded this and i'll just go ahead and open up sublime and we can take a look at this and so what you'll get is the core sdk here as late as for any good software comes with documentation that you can dive into and then a bunch of examples so a lot of this will be driven from the examples that are provided to us from the sdk and so just for the purposes of our first uh deployment of working software uh we'll just do the hello world so in order to get into that the steps are to get into the hello world directory and then you'll need to actually copy the sdk into the local directory one second please so what that looks like is here within the examples we have hello world uh but we do actually when we we're gonna package this up into a zip file and create a lambda inside of the console with that so we do actually need the the proper green grass sdk to be packaged up uh with our lambda code as well and so this is a very simple example that all of all it's going to do is um once it connects it's just going to publish to a hello world topic um and it's going to say hello world sent from and it's going to uh specify the platform that it is sent from and so with that being the case this looks like uh once the sdk is copied into that hello world example going out and zipping up the lambda itself as well as the sdk folder and we'll put that into a helloworldpythonlambda.zip file and so with that being the case i went ahead and this ahead of time well if you run that command the hello world python lambda zip file is created and also something that i want to point out if you want more verbose instructions this is all available from the green grass tutorial and you can find that by simply going out and searching for green grass tutorial and this will go through these steps in in more detail so definitely go out and check this out if you want to get some hands-on experience with the service so at this point we are into uh module number three and so this should look pretty familiar and so the the play here is now that we have the zip file we want to go ahead and create the lambda itself and so let's jump into the lambda service and so the first step to this is to create a lambda and so there's nothing special here this is like any other standard lambda the create function was is where you want to go if you haven't done this before again very verbose instructions within the tutorial itself i went ahead and set this up ahead of time for the purpose of for the purposes of time and so that being the case if you want to go ahead and configure this you'll want to upload from the zip file that you just created and then additionally you will want to get in here and configure the runtime to python 3.7 as well as the handler that is basically the entry point into the code when the lambda is invoked and this greengrasshelloworld.functionunderscorehandler that actually comes from the code itself where we have greengrass hello world so with that being the case um we now have the lambda itself configured and the next step is to create in and this is optional but this is recommended uh create an alias and so uh once we get into creating the alias um i went ahead and gave it the name gg underscore hello world uh and then i point it to a version so if we want to get into what the configuration of this looks like you just give it a name and a version so let me actually back up a sec and so you name it and then you can give it the uh the tag latest will just be the most recently version published version of the lambda or you can have an explicit version itself and so what the alias does is when you start to configure that within your green grass group you point to the alias and not a specific version and this allows you to behind the scenes update the lambda without having to need to actually update the configuration of the lambda and its inclusion within the green grass group and i'll get into that in just a second so diving back into these slides um we give it the alias and then we go ahead and add it to the group so diving back into the green grass group itself to add the lambda to the green grass group you want to get into the group and i'll just go ahead and go with the group that i've already configured and so here you have the lambdas submenu option you'll want to dive into that and then hit add lambda and so since we've already defined the lambda we go into use existing and these should look familiar we've got green grass hello world and then you can configure this to point to a specific version or you can configure it to point to the alias and since we can use the aliases a bit of indirection to be able to maintain and configure and update versions behind the scene it is recommended that you point to an alias itself so if that being the case we'll jump back and back and back one more time and so at this point we need to uh go ahead and set up what's called subscriptions and so this is a pretty core element of green grass itself and so what we'll want to do is configure the hello world green grass subscription so to dive into what this looks like we'll select a source and a target and so what we'll want to do is from the lambda that's deployed to the green grass core node we'll want to send that out to the iot cloud here and so once you select the source and the target the topic is just hello and world so this has already been configured so i'm going to jump back over into the group and the next step is to actually deploy out to the device and so this is pretty cool so here we can jump into the group itself and go ahead and let's see here and actually deploy the configured software and so here at the core of the group hit the actions and hit deploy and so what this will do is actually deploy the lambda as well as the description out to or the subscription out to the device and so once this has completed uh if you want to test the communications itself we can get into the mqtt test client and so here we want to check out what's going on on the topic itself we'll have uh hello world test and the lambda itself is going to run every 25 seconds so we'll wait a little while for this to to come across the air so let's jump into this interesting since we are dealing with a demo of course we get the demo bugs sometimes it just is like that let's go ahead and give this a subscript let's go ahead and attempt to deploy this again on deployment it will tell you that it started the deployment itself and you'll see that it's pending out here it'll tell you that it's in progress and this usually happens pretty quickly unless the device itself is not up and running and so we have completed the deployment so this is pretty cool definitely worth pointing out that uh by just a few clicks in the portal we've sent uh software out to the raspberry pi itself and it is up and running and so i'm not sure what's going on to be honest with you but we're having some demo bugs let's take a quick look at the configuration and so in here we've got a 25 second timeout on the lambda if you're familiar with lambda um you'll you'll understand that this is the how long this can run for before it times out and then there's also the option to configure this as an on-demand lambda which be triggered from a subscription within green grass or to make it a long lived lambda that keeps running indefinitely and definitely on the device um let's see here i think i have an idea what's going on i think i may be paying attention to the wrong topic okay yep i think that's what's going on so like a goof i got the wrong subscription so all right so we've successfully troubleshooted this so now we're seeing the messages coming from the green grass core device itself okay so let's dive back into these slides and so at this point we have created the lambda we added it to the green grass group we went ahead and deployed it over the air to the green grass pie and then we also went ahead and set up a subscription from that lambda to the iot cloud or aws on the hello slash world topic we have seen this as well so we've seen communications from the device so this is all pretty cool but it's just a basic hello world use case and so now that we've kind of seen the software in action i do want to dive into a very core aspect of the platform itself of the service itself and that is the message queuing telemetry transport or mqtt and so this is a tcp based vip protocol based messaging standard that's been intended and optimized for iot or the internet of thing internet of things it provides a pub sub architecture and so that you can provide the many to many communications that uh drive an event driven architecture it's very lightweight and efficient it is bi-directional so data can be sent from the device to aws or from a2 aws to the device or from a device to another device it is secure we've got the certificates in place as we've seen and then it's also reliable on unreliable networks if the internet connection goes down in your on-prem network you've still got these topics being maintained by the green grass core node itself and so also just a quick note on the on-demand versus long-lived lambdas we took a look at it in the console uh greengrass offers the on demand or long-lived options there and so to kind of dive into why that would be important let's take a look at a code example and so another example that's provided in the examples another sample provided in the examples is the green grass counter and so here standard to lambda we have the function handler itself but it also has outside of the function handler a counter and so every time that um it is invoked the counter is incremented by one and then this message is sent out to um aws on the hello world counter topic and i'm not going to set this up for the purpose of time but in the scenario that a function is uh on demand this counter variable is always initialized and set to zero and then incremented and sent over so every time it is equal to one and so if it's long lived the state the counter is maintained and then um say the second time that the lambda is invoked this counter itself will be equal to 2. so this allows you to keep some some level of state within your lambda that's running on the green grass chord node okay and so we we touched on subscriptions pretty briefly but i do want to dive back into the portal and kind of show you some of the options there so diving into the group we can't dive into subscriptions and then just to kind of show off the possibilities the add subscription option here and so here we went from a source of the hello world lambda to a target of iot cloud so we send this out to aws but we have um other options as well and so we could have that lambda that's running in a long-lived manner and it could send messages out to a device that we set up and so that gives us some options in terms of where messages come from and go to and so another and we're not going to get too far into this for the purposes of time today but another option here is a connector and so the lambda could uh send to a connector that then dumps data into say a database for example and so this allows you to source events from say like a database use an mqtt topic and send it to say a device or a lambda running on the green grass core node itself and so these subscriptions are pretty powerful in a core aspect of the service okay and so let's go ahead and dive into devices and so as we can see from the uh the diagram here we've got aws iot core and we've uh worked a little bit with the the green grass core node itself but what about in the internet of things the things themselves so we have the publisher device as well as the subscriber device in this diagram and so this allows one device to interact with another device via the green grass core uh node and is this is done again over the mqtt protocol and so one of the powerful things with the service itself is the the devices do not need to know the specifics of the other devices for example the ip address of the subscriber is not known to the publisher as the message queuing protocol is used and so the subscriber simply subscribes to the cue name that the publisher is publishing to and then that way it basically doesn't have to know the specifics of the publisher itself okay and so the the basic example from the tutorial is that publisher and subscriber i'm not going to get into actually deploying this we have a more advanced device use case a little bit later but we can take a quick look at the code and i'll increase the size of this and so in the tutorial they get into a publisher and a subscriber in order to create the devices and this goes into the security first design of the service itself we can go out and create devices and so within the group itself there's a devices submenu and so this is um to create a new device that's where this will take you you'll name it and as we saw with the greengrass core node setup it'll give you a whole bunch of certificates files that you'll need to get onto the device and so that being the case once this is configured the let's go into the publisher they have a basic discovery service here that takes the end point of your uh your green grass cluster uh the uh the files from the certificates a name a topic in a mode and this simply goes out and the if you run in the publisher mode it will put messages on to the topic and if you run in the subscriber mode it'll pick up messages off of the topic and so uh this is this is pretty straightforward in a pretty basic use case but if you go through the tutorial this is where they will take you to begin with just to get the basic fundamentals of a device within green grass and so to dive into a more complex subject within devices green grass has the concept of a device shadow and so a device shadow is basically the state of a device and this allows other devices to manipulate a device without having to connect to it directly and so we'll get into a use case here in which the iot shadow is used to drive the color of a traffic light and there's an actual device the traffic light controller that tells the traffic light when to change and since the traffic light device pays attention to the traffic light iot shadow when the traffic light controller sends a message to the iot shadow to change the state of the traffic light the traffic light will pick up that change and then change its state itself and so to dive into this let's go ahead and jump into the next slide so what we have done out in the portal again going into the green grass group itself and jumping into the devices went ahead and set up a gg switch device and so in this we just went ahead and followed the setup for the device so let's go ahead and just kind of jump into what that looks like so there's a an advanced setup as well as a one-click setup would recommend just using the one-click setup just for these kind of basic tutorials and basic use cases and so here similar to the green grass core node setup it'll go ahead and give you a set of certificate files you'll want to download these as well as the certificate authority and so the setup of the devices in the meetup group was done for both the green grass switch as well as the traffic light itself and so the additional step here is to set up a shadow for the device which represents the desired state of the device and so that's as simple as jumping in and giving creating a shadow and so there's the ability to create the classic unnamed shadow or a named shadow and so with the name shadows which is a fairly new feature this gives you the ability to have multiple states for a single device and so i think that's more of an advanced use case we'll kind of leave that alone for today but i did want to let you know that that feature is available and so to dive into the use case here around the traffic light controller setting the state of the traffic light via the iot shadow let's go ahead and dive into some code and so again this comes out of the examples from the sdk so we have the traffic light and the traffic light controller so let's dive into firstly the traffic light itself and so here went ahead and got the device certificate files and added them to the local directory with this traffic light.py file and so the and so we'll get back into the callback here but the what happens when the device in this case the simulated device starts up is it goes out and it discovers the green grass core node so to kind of put a picture to that upon startup of the script the device goes out and hits the iot core group and gets the information about the green grass core device that is on the local area network and so this example here goes ahead and gets the certificate paths and then it will go out and hit the discover method from the sdk talk to aws and figure out how to talk to the greengrass chord node and so once it successfully connects to aws it'll get the connectivity info list and then inside of that is a set of addresses and so we saw on the let's see here so registered within the connectivity infos is the ip address of the green grass core device itself the ipv4 then also the ipv6 address is also registered and another address that's registered within that connectivity list is the localhost loopback127.0.0.1 um an important note if you walk through uh the tutorial and you use a device um that's let's say you use the raspberry pi for your green grass core uh and then in this case i'm using just my local laptop for uh the simulated traffic devices um this will the first address that i found that it was coming back with is 127.0.0.1 and so just the gotcha i want to warn you about um is when i tried to run this the first time the first address that came back that they have this is ip address this is specific to v4 jumping into here it's going to look for the four octets that make up an ip address the first one that came back was the localhost loopback and so that didn't work because i'm running uh the green grass core node on raspberry pi which is not my local laptop so i ended up having to modify the script itself to say uh i don't want it to use 127. okay so once we get the connectivity information the script itself will go ahead and just print that out it'll go ahead and configure the certificate information if it can't discover the device it'll go ahead and fail and then at that point it'll go ahead and connect into the green grass core device and then we'll start working with the device shadow and so here this is the traffic light itself and so this simply waits for updates to the device shadow so those actually come from the uh the light controller and so very similar here it will come up and perform discovery you'll have to add the uh the logic to omit 127.0.0.1 here then i'll go through all the authentication and discovery and then the important thing to note here is at the end that what it's going to do is it's going to wait i believe 20 seconds here and it's going to go ahead and produce a new device shadow update so this is going to update the desired state of the traffic light itself and what it's simply doing is from the different states green yellow red it's just going to cycle through these and so this is just a cycle so this for loop runs indefinitely and so uh it will just go ahead and produce the next state uh onto the topic that updates the device shadow and then it sleeps for 20 seconds so to see that in action let's go ahead switch back over to the command line and so what i've got here is i've got the traffic light and so i'll go ahead and run the traffic light uh python script here specifying the iot end point for my green grass group i will specify these certificates as well here specify a thing name of gg traffic light as well as a client id of gg traffic light so we'll go ahead and start this up okay so everything goes well it just tells you that it's subscribed to the delta topic uh for the device shadows for the gg traffic light device name a another gotchu i will warn you about that if you run this on one network and it discovers the green grass core host it writes out this file with the ip address of that host if you uh switch up the host ip address for some reason say that you take your raspberry pi and you put it on to a new network then it will have difficult difficulty connecting to that device in order to fix that you'll just want to delete this group ca folder and that remedies that issue okay so now that we have the traffic light simulator running we want to go ahead and get the controller running as well and so again if you're switching networks new ip address you'll definitely want to delete the group ca directory before you run the traffic light or traffic light switch simulator again and so with that being the case now we've got the um we've got the um the traffic light controller up and running and we've got the subscribe delta topic over here and so at this point pretty soon okay so the controller itself after it waited 20 seconds went ahead and produced a message for the device shadow the intended state of the traffic light itself to go ahead and turn into yellow and so over here as the device itself was waiting and listening to updates for the device shadow it picks up the change to the device shadow and changes to the desired state we just produced a new message with red as the desired state and so at this point the traffic light simulator has changed its state to be r which is to simulate red and again we see it cycle back into green after 20 more seconds and so that gives us the very simple use case of one application uh modifying this or sorry one device modifying the state of another device by interacting with the device's iot shadow so the use cases are pretty powerful here when you start to talk about real world iot use cases if you tuned into the iot part 1 uh meetup we we showed a simulation of kind of a sensor network in which the pressure and temperature were being read and so say this is more of like an industrial use case where um you have a sensor that's picking up on temperature and pressure and some sort of manufacturing process if you have this device that's looking at those sensor readings and says that you know we don't want the pressure to be above a certain number and please shut it down once you get above a certain threshold this would be a way to go ahead and make that possible and more of an industrial type of use case and so that brings us to the end of the demo for today's presentation and so i do want to cover some of the available advanced topics that are out there with green grass green grass does give you the ability to keep your secrets locally on the green grass core and so to do secrets management locally without having to connect to aws if you have a lot of devices there's a group management feature there if you want to do machine learning at the edge greengrass also supports that they have security intrusion detection i've added a link to the pricing here as well as a stream management component of green grass so thank you for tuning in that concludes the presentation i'll stay on the stream for a few minutes to see if there's any questions and if not i hope you all have a good evening like we have no questions on the stream so

Channel: AWS Meetup Group

Views: 1,376

Keywords: Kubernetes, AWS, Technology, Software, Containers

Id: HpEDDCAZiCM

Length: 57min 28sec (3448 seconds)

Published: Thu Mar 25 2021