For this project, we will assume that we're building an e-commerce platform. This platform will include product browsing, shopping cart functionality, user authentication, payment processing, and product reviews. The requirements and architecture for the project could be as follows:
Requirements Gathering (Day 1-2)
Users should be able to view, search for, and purchase products.
Users should be able to review products they have purchased.
Users should be able to create accounts, log in, and manage their profiles.
Users should be able to add products to a cart before purchasing.
Payment should be processed securely, and users should receive a confirmation email when a purchase is made.
Planning & Architecture (Day 3-5)
We will use a three-tier architecture for this e-commerce platform:
Front-end tier: This will be the user interface presented to the end-users. It will be hosted on EC2 instances and deployed through Elastic Beanstalk. Static assets and resources for the front-end will be stored in S3 and served through CloudFront for fast, global access. AWS Cognito will be used for user authentication and session management.
Application tier: The business logic of the application will be implemented as a set of REST APIs, using Lambda and API Gateway. The user activity will be logged in CloudWatch Logs for monitoring and debugging.
Data tier: The user data and product catalog will be stored in DynamoDB. All product images and user uploaded files will be stored in S3. ElasticSearch will be used for search functionality.
Implementation Phase
Day 6-8: Setting up AWS Environment and EC2 instances
Set up AWS environment including IAM roles, security groups, EC2 instances and Elastic Beanstalk for application deployment.
Day 9-10: Network and Storage Configuration
Learn about and set up NAT gateways, EFS, and storage-optimized EC2 instances.
Day 11-12: Scaling and Load Balancing
Learn about and implement Auto Scaling groups, Load balancing, and Beanstalk configurations for the application.
Day 13-14: Introduction to S3 and CloudFront
Set up S3 for static content and CloudFront for CDN. Implement file uploads to S3.
Day 15-16: DynamoDB and VPCs
Learn about DynamoDB and create tables for the application.
Implement VPCs, subnet design, and gateway endpoints.
Day 17-18: AWS Lambda and Rest API with API Gateway
Implement business logic in Lambda functions and expose them via API Gateway.
Day 19: Exploring Other AWS Services
Learn about and explore other AWS services like SES for sending emails, CloudWatch for monitoring, Cognito for user management, and so on.
Day 20: Completion, Testing and Cleanup
Review all components, ensure everything is functioning as expected.
Perform load testing and failure testing.
Discuss cost optimization, best practices, and security measures.
Remind students to clean up their resources to avoid unexpected costs.
Throughout this process, students will get hands-on experience with a wide variety of AWS services and will learn how to design and implement a full-stack application on AWS. Encourage students to experiment and extend the project with additional features like recommendations, user favorites, product categories, etc. to get additional practice and experience.
Absolutely! If you'd prefer a JavaScript-based project, "react-shopping-cart" is a simple yet full-fledged e-commerce website built using React and Redux. This project provides a good starting point for a shopping cart, and you can add more features like user authentication, product reviews, and more as per the workshop requirements. Here's the GitHub link: https://github.com/jeffersonRibeiro/react-shopping-cart Please note that while this project provides a good front-end starting point, it doesn't include a backend for managing product and order data. You could build a serverless backend with AWS Lambda and API Gateway for managing products and orders, and store your data in a DynamoDB table. Remember, since this project is built with React, you will need to have Node.js and npm (Node Package Manager) installed to work with it. Furthermore, as this application is open-source, make sure to respect the license (MIT in this case) when using it. As mentioned earlier, the students may need to modify the project to fully utilize AWS services, and this could be an excellent learning opportunity for them to understand how a full-stack JavaScript application can interact with various AWS services. Day 1-2: Requirements Gathering
Over the course of the first two days, we'll gather detailed requirements to understand the functionality that our application must provide. This understanding is crucial to the design and implementation phases of our project.
Day 1: User Interaction Requirements
We'll begin by discussing and detailing the user interaction requirements:
Product Browsing and Searching: The application should display a catalogue of available products. Users should be able to search through this catalogue by typing in search terms or by applying filters like category, price range, etc.
User Accounts and Profile Management: Users should be able to register for an account, log in, and manage their profiles. The profile management features might include updating contact information, changing password, managing payment methods, etc.
Shopping Cart Functionality: Users should be able to add products to a shopping cart, view the contents of their cart, update quantities of items in the cart, and remove items from the cart.
Day 2: Transaction and Notification Requirements
After detailing the user interaction requirements, we'll discuss the transaction and notification requirements:
Secure Payment Processing: When a user decides to purchase the items in their cart, the application should provide a secure checkout process. This includes securely handling sensitive information like credit card details and processing payments reliably.
Order Confirmation and Email Notification: After successfully completing a purchase, users should receive a confirmation message on the application and an email notification with order details.
Product Reviews: Once a user has purchased a product, they should be able to leave a review for that product. This feature should include both rating (on a scale, for example, 1-5) and text comments.
By the end of Day 2, we should have a comprehensive list of requirements for our e-commerce application. This will provide a solid foundation to design the application architecture and choose the appropriate AWS services.
Day 3-5: Planning & Architecture
The proposed architecture for our application involves dividing it into three tiers. This is a common approach in the development of scalable applications as it provides separation of concerns, which can lead to more maintainable and scalable systems.
Day 3: Front-end Tier Planning
The front-end tier is responsible for all user-facing components. It includes everything that the user interacts with directly. We'll spend this day planning and discussing the following elements:
EC2 and Elastic Beanstalk: We'll deploy our front-end code (HTML, CSS, JavaScript) onto EC2 instances. Using Elastic Beanstalk, we can manage and handle the deployment process, including capacity provisioning, load balancing, and automatic scaling.
S3 and CloudFront: All static content, such as images, stylesheets, and JavaScript files, will be stored in an S3 bucket. We will use CloudFront, a content delivery network (CDN), to serve these static files to the end-users quickly, no matter where they are globally.
AWS Cognito: To manage user authentication and session management, we will use AWS Cognito. It provides a secure and scalable user directory, which can scale to hundreds of millions of users.
Day 4: Application Tier Planning
The application tier is where the business logic of the application lives. This tier receives requests from the front-end, processes them, and sends back a response. The main elements to plan and discuss on this day are:
Lambda and API Gateway: We'll build our serverless backend using Lambda functions, and these functions will be triggered by API Gateway. Each function will contain business logic for a specific API endpoint.
CloudWatch Logs: We will use CloudWatch Logs to monitor our application and store its logs. This will help us in debugging and understanding the behavior of our application over time.
Day 5: Data Tier Planning
The data tier is responsible for storing and retrieving all of the data that our application uses. The key elements we'll plan and discuss on this day include:
DynamoDB: We'll use DynamoDB, a NoSQL database, for storing our user data and product catalog. DynamoDB provides low-latency performance at any scale, and it's a great fit for e-commerce applications.
S3: All product images and files uploaded by users will be stored in S3. It's a highly scalable, reliable, and secure service for object storage.
ElasticSearch: To provide robust search functionality in our application, we'll use AWS ElasticSearch. This will enable users to easily search through our product catalog using various search terms and filters.
By the end of Day 5, we will have a clear plan for the architecture of our application and a deep understanding of how each AWS service fits into that plan.
Day 6: AWS Identity and Access Management (IAM) & Security Groups
IAM is a web service that helps you securely control access to AWS resources. You use IAM to control who can use your AWS resources (authentication) and what resources they can use and in what ways (authorization).
Tasks include: Creating new IAM users for each student, assigning necessary permissions, setting up multi-factor authentication, and explaining IAM best practices.
Security Groups act like a virtual firewall that controls the traffic for one or more instances. When you launch an instance, you can specify one or more security groups; otherwise, we use the default security group.
Tasks include: Creating and configuring Security Groups, understanding inbound and outbound rules, and learning how to assign Security Groups to EC2 instances.
Day 7: Amazon EC2 (Elastic Compute Cloud)
EC2 is a web service that provides resizable compute capacity in the cloud. It is designed to make web-scale cloud computing easier.
Tasks include: Learning about EC2 instances, launching, connecting to, and stopping instances. Exploring instance types and understanding Amazon Machine Images (AMIs). Setting up EC2 instances to host our application, which involves installing necessary software like Node.js for a JavaScript application.
Day 8: AWS Elastic Beanstalk
Elastic Beanstalk is an easy-to-use service for deploying and scaling web applications developed with Java, .NET, PHP, Node.js, Python, Ruby, Go, and Docker, among others.
Tasks include: Creating an Elastic Beanstalk application, explaining environments, versions, and environment configurations. Deploying our sample application using Elastic Beanstalk, and understanding how Elastic Beanstalk simplifies infrastructure management.
By the end of day 8, students will have hands-on experience with key AWS services involved in hosting, managing, and deploying applications. They will have a functional environment set up ready for further development and configuration in the coming days.
Day 9-10: Network and Storage Configuration Learn about and set up NAT gateways, EFS, and storage-optimized EC2 instances.
Day 9: Network Configuration - NAT Gateways
A Network Address Translation (NAT) gateway allows instances in a private subnet to connect to the internet or other AWS services, but prevents the internet from initiating a connection with those instances. This is essential for our instances to communicate with the outside world while maintaining a secure environment.
Tasks include: Explaining what a NAT Gateway is, how it works, and when to use it. Creating a NAT Gateway in a public subnet and configuring route tables in private subnets to use the NAT Gateway for internet traffic.
Day 10: Storage Configuration - EFS and Storage-optimized EC2 instances
Amazon Elastic File System (EFS) provides a simple, scalable, fully managed elastic NFS file system for use with AWS Cloud services and on-premises resources. It's designed to support a wide variety of use cases, from home directories to container storage and big data applications. We can use EFS for storage that can be accessed concurrently from multiple EC2 instances.
Tasks include: Explaining what Amazon EFS is, creating an EFS file system, and mounting the file system from an EC2 instance.
Storage-optimized EC2 instances are designed for workloads that require high, sequential read and write access to large data sets on local storage. They are optimized to deliver tens of thousands of low-latency, random I/O operations per second (IOPS) to applications.
Tasks include: Learning about different EC2 instance types, what storage-optimized instances are, and when to use them. Migrating our application to a storage-optimized EC2 instance if required.
By the end of Day 10, students will understand how to configure and use NAT Gateways for network configuration and how to utilize Amazon EFS for shared storage requirements. They will also get a sense of different EC2 instance types and how to choose the right one according to their application needs.
Day 11-12: Scaling and Load Balancing
These two days will be focused on understanding and implementing AWS services for managing scalability and traffic distribution - specifically Auto Scaling groups, Load Balancing, and Elastic Beanstalk configurations.
Day 11: Auto Scaling Groups
Auto Scaling ensures that you have the correct number of EC2 instances available to handle the load for your application. Auto Scaling can be used to help ensure that you are running your desired number of EC2 instances, and it can automatically increase or decrease capacity as needed.
Tasks include: Learning about and creating an Auto Scaling group, understanding scaling policies, setting up automatic scaling based on different metrics such as CPU utilization. Migrating our application to the Auto Scaling group.
Day 12: Load Balancing & Elastic Beanstalk Configurations
Load Balancing distributes incoming application traffic across multiple targets, such as EC2 instances, in multiple Availability Zones. This increases the availability and fault tolerance of your applications.
Tasks include: Understanding the concept of load balancing, creating and configuring an Application Load Balancer, registering the EC2 instances from the Auto Scaling group to the Load Balancer.
Elastic Beanstalk configuration files (.ebextensions) can be used to customize the software on Elastic Beanstalk instances and other parts of the environment. This can be used to further tune our application environment for scalability and performance.
Tasks include: Learning about .ebextensions, creating a configuration file to customize our environment, understanding environment variables and how they can be used in Elastic Beanstalk.
By the end of Day 12, students will understand the concept of scalability in the cloud, how to automatically scale EC2 instances based on demand, how to distribute incoming traffic among multiple instances for better performance, and how to further customize their Elastic Beanstalk environment for their application needs.
Day 13: Introduction to S3 and setting up a bucket
Amazon S3 (Simple Storage Service) is an object storage service that offers industry-leading scalability, data availability, security, and performance. This allows it to be used for a wide variety of use cases, including website hosting, backup and restore, archive, enterprise applications, IoT devices, and big data analytics.
Tasks include: Learning about S3 and its key features, creating an S3 bucket, uploading, and retrieving files from the bucket. We will modify our application to store static content like images and product data on S3.
Day 14: Introduction to CloudFront and implementing file uploads to S3
Amazon CloudFront is a fast content delivery network (CDN) service that securely delivers data, videos, applications, and APIs to customers globally with low latency, high transfer speeds, all within a developer-friendly environment.
Tasks include: Learning about Content Delivery Networks and the benefits of CloudFront, creating a CloudFront distribution for our S3 bucket to cache and deliver content. We will also implement file upload functionality in our application to allow users to upload files directly to S3.
By the end of Day 14, students will understand how to use S3 for scalable, secure file storage and how to use CloudFront to deliver content faster to users. They will also learn how to implement file upload functionality in their application.
Day 15: Introduction to DynamoDB
Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale. It's a fully managed, multiregion, multimaster database with built-in security, backup and restore, and in-memory caching for internet-scale applications.
Tasks include: Understanding the basics of DynamoDB, its data model, and how it differs from SQL databases. Creating tables in DynamoDB for our application and inserting and retrieving data. Modifying our application to use DynamoDB as its data store.
Day 16: Introduction to VPC and Subnet Design
An Amazon Virtual Private Cloud (VPC) is a virtual network dedicated to your AWS account. It is logically isolated from other virtual networks in the AWS Cloud. You can launch your AWS resources, such as Amazon EC2 instances, into your VPC.
Tasks include: Learning about VPCs, subnets, security groups, and network access control lists. Creating a VPC with public and private subnets. Understanding gateway endpoints and implementing one for S3 and DynamoDB.
By the end of Day 16, students will be able to create and manage DynamoDB tables and understand how to use them in their application. They will also gain a solid understanding of AWS VPCs, how to design their network, and how to restrict and control access using security groups and network access control lists. They will also implement gateway endpoints to enable private connections between their VPC and AWS services.
Day 17: Introduction to AWS Lambda
AWS Lambda is a serverless compute service that lets you run your code without provisioning or managing servers. With Lambda, you can run code for virtually any type of application or backend service - all with zero administration.
Tasks include: Understanding the concept of serverless architecture and when to use it. Creating a simple Lambda function and testing it. Learning about the different ways to trigger a Lambda function and integrating it with our DynamoDB database.
Day 18: Rest API with API Gateway
Amazon API Gateway is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale. API Gateway handles all the tasks involved in accepting and processing up to hundreds of thousands of concurrent API calls, including traffic management, authorization and access control, monitoring, and API version management.
Tasks include: Understanding REST APIs and their principles. Creating a REST API using API Gateway. Configuring routes, methods, and integrations. Integrating the API Gateway with our Lambda functions to expose them as APIs. Modifying our application to use these APIs for data manipulation.
By the end of Day 18, students will have a solid understanding of serverless architecture and the benefits it provides. They will know how to create and manage Lambda functions and create REST APIs using API Gateway. They will also understand how to integrate these services with their existing application and infrastructure.
API Endpoints: Each Lambda function will correspond to an API endpoint in our e-commerce application. For example, there could be Lambda functions for creating an account, logging in, adding an item to the cart, submitting a purchase, and so on. These functions will contain the business logic for processing these requests, such as interacting with the DynamoDB database or calling other AWS services.
Event-driven Processing: In addition to explicit API calls, Lambda functions can also be triggered by event notifications in AWS. For instance, we could set up a function that gets triggered every time a new user signs up (an event in Cognito), which could then send a welcome email via AWS Simple Email Service (SES).
Integration with Other AWS Services: We can use Lambda functions to interact with other AWS services, such as DynamoDB, S3, CloudWatch, Cognito, etc. For instance, a Lambda function could read/write data from/to DynamoDB, log custom messages to CloudWatch, generate presigned URLs for secure file upload to S3, and more.
Serverless: Since Lambda is serverless, we don't have to worry about server management, capacity provisioning, patching, etc. Lambda automatically scales our application in response to incoming request traffic, and we only pay for the compute time we consume - there is no charge when our code is not running.
To set up these Lambda functions, we'll need to write our business logic code (in a language supported by AWS Lambda), package it with any dependencies, and upload it to Lambda. We'll also need to define the event triggers (e.g., API Gateway requests, S3 bucket notifications, etc.) that will cause each Lambda function to execute.
Day 19: Exploring Other AWS Services Learn about and explore other AWS services like SES for sending emails, CloudWatch for monitoring, Cognito for user management, and so on.
Day 19: Exploring Other AWS Services
On this day, we'll dive into some additional AWS services that can be used to enhance our application.
Amazon SES (Simple Email Service)
Amazon SES is a cloud-based email sending service designed to help digital marketers and application developers send marketing, notification, and transactional emails. It's a reliable, cost-effective service for businesses of all sizes that use email to keep in contact with their customers.
Tasks include: Understanding the benefits of Amazon SES, setting up and verifying a new email address, and integrating Amazon SES with our application for sending email notifications.
Amazon CloudWatch
Amazon CloudWatch is a monitoring and observability service built for DevOps engineers, developers, site reliability engineers (SREs), and IT managers. CloudWatch provides you with data and actionable insights to monitor your applications, understand and respond to system-wide performance changes, optimize resource utilization, and get a unified view of operational health.
Tasks include: Understanding the importance of monitoring, learning how to navigate the CloudWatch console, setting up alarms for certain metrics, and viewing logs.
Amazon Cognito
Amazon Cognito provides authentication, authorization, and user management for your web and mobile apps. Your users can sign in directly with a username and password, or through a third party such as Facebook, Amazon, or Google.
Tasks include: Learning about user authentication and authorization, setting up a user pool in Cognito, integrating Cognito with our application for user management.
By the end of Day 19, students will have a deeper understanding of how to use AWS services to manage various aspects of their applications such as user management, email notifications, and monitoring. They will have hands-on experience integrating these services with their application.
Day 20: Completion, Testing and Cleanup
The last day will be dedicated to reviewing, testing, and cleaning up all the work done during the workshop.
Review All Components
We will start by ensuring that all components of our application and AWS infrastructure are functioning as expected. We will perform a comprehensive review of every element, including but not limited to:
AWS EC2 instances
Auto Scaling group
Load balancing
AWS S3 and CloudFront configurations
DynamoDB tables
AWS VPCs and subnets
Lambda functions
REST API via API Gateway
Amazon SES, CloudWatch, and Cognito configurations
Testing
Once we've confirmed that everything is set up correctly, we'll conduct a series of tests. This includes:
Load Testing: Simulate high user traffic to ensure that our application can handle the load and that auto-scaling is working correctly.
Failure Testing: Simulate component failures to ensure that our application is resilient and can recover smoothly.
Discussion
We'll also have a discussion on cost optimization, best practices, and security measures. This includes:
Cost Optimization: We will discuss different strategies for reducing costs in AWS, like using reserved or spot instances, proper auto-scaling, and efficient data transfer strategies.
Best Practices: We will talk about general AWS best practices, including architecting for failure, decoupling your components, using edge locations, etc.
Security Measures: We will go through important security considerations, such as least privilege principle for IAM, security group and NACL configurations, encryption at rest and in transit, etc.
Cleanup
Finally, to avoid incurring any unnecessary costs, it's important that students clean up their resources after the workshop. We will guide them on how to properly delete their AWS resources in the right order to avoid any dependencies.
By the end of Day 20, students will have a fully functional and tested application hosted on AWS. They will understand how to optimize costs, adhere to best practices, and secure their application. They will also know how to properly clean up their AWS resources.
Comments