Hands-on Workshop on Developing AWSome App - a Serverless Food-delivery Application
            Abstract:
            Get hands-on experience with AWS and serverless applications in this workshop conducted by experts from
              AWS. 
            In this workshop you'll deploy a simple web application that enables users to request food from the
              AWSome Food
              website using services like AWS Lambda, Amazon API Gateway, Amazon S3, Amazon DynamoDB, AWS Step
                Functions and
                Amazon Cognito. 
            
              With the knowledge from the workshop, you can build and deploy your own serverless applications using
              these services
              for common use cases like web applications, analytics, and more.
            
            Format:
            
              Full-day hands-on workshop (yes, do bring your laptops). The timings are as below:
              
09.30am - 10.00am: Registration cum installation & setup 
              10.00am - 11.30pm: Session 
              11.30am - 11.45am: Tea break 
              11.45am - 01.00pm: Session
              01.00pm - 02.00pm: Lunch
              02.00pm - 03.30pm: Session
              03.30pm - 03.45pm: Tea break
              03.45pm - 05.45pm: Session 
              05.45pm - 06.00pm: Wrap-up / closure    
            
            Application – Technical Description:
            
              The application will present users with an HTML & JS based user interface for ordering food items and
              indicating the
              location where they would like the food to be delivered. The interface on the backend with a RESTful web
              service will
              submit the request and find and dispatch food to the requester’s location. The application will also
              provide
              facilities for users to register with the service and log in before ordering food.
            
              The application architecture uses S3 hosts static web resources including HTML, CSS, JavaScript, and image
              files which
              are loaded in the user's browser. JavaScript executed in the browser sends and receives data from a
              backend API built
              using Lambda & Step Functions and API Gateway. Amazon Cognito provides user management and authentication
              functions to
              secure the backend API. Finally, DynamoDB provides a persistence layer where data can be stored by the
              API's Lambda
              function.
            Pre-requisites:
            
              - AWS Account: In order to complete this workshop you'll need an AWS Account with
                access to create
                AWS IAM, S3, DynamoDB,
                Lambda, Step Functions, API Gateway and Cognito resources. All of the resources you will launch as part
                of this
                workshop
                are eligible for the AWS free tier if your account is less than 12 months old. See the AWS Free Tier page for more
                details.
 
              - Essential JavaScript, HTML/CSS & Python knowledge: The front-end used JS and HTML/CSS
                and the
                backend code is written in
                Python; hence working knowledge is needed on these languages for this workshop.
 
            
            
              Agenda:
              
                Session 1: Getting Started with Serverless Development
                
                  - 
                    Essentials of serverless development
                  
 
                  - 
                    Introduction to the essential AWS services used in this workshop and how they relate to each other:
                    AWS Lambda,
                    Amazon API Gateway, Amazon S3, Amazon DynamoDB, AWS Step Functions and Amazon Cognito.
                  
 
                  - 
                    Hands-on: Clone the GitHub repo for the “AWSome Food” application
                  
 
                
               
              
                Session 2: Static Website Hosting
                
                  - 
                    How to use S3 for static website hosting
                  
 
                  - 
                    Hands-on: Create an S3 bucket, upload content, add a bucket policy to allow public reads, and enable
                    website
                    hosting; validate the hosted website
                  
 
                
               
              
                Session 3: User Management
                
                  - 
                    How to perform user authentication and registration with Amazon Cognito User Pools
                  
 
                  - 
                    Hands-on: Create an Amazon Cognito user pool, add an application client, updating the Config.js file
                    in your
                    website
                    bucket, and validate the implementation.
                  
 
                
               
              
              
                Session 4: Serverless Service Backend 
                
                  - 
                    How to use AWS Lambda, Step Functions, and Amazon DynamoDB to build a backend process for handling
                    requests from
                    your
                    web application.
                  
 
                  - 
                    Hands-on: Create DynamoDB table, create an IAM role for the lambda and step functions, create
                    lambdas for
                    handing
                    requests; validate implementation
                  
 
                
               
              
                Session 5: RESTful APIs with AWS Lambda and Amazon API Gateway
                
                  - How to use API Gateway to expose the created lambda and step functions as a RESTful API.
                  
 
                  - Hands-on: Create a new REST API, create a Cognito User Pools Authorizer, create a new resource and
                    method,
                    deploy your
                    API, update the website config; validate the implementation.
 
                
               
              
                Session 6: Putting things together and next steps
                
                  - How to test the implementation & perform load testing
 
                  - How to monitor the application, logging, debugging, etc
 
                  - Wrap-up and key takeaways