AWS & React: Deploy an Auto-Scaling E-Commerce App with ELB

Generate and review an iam credentials report to audit user activity, rotation of passwords and access keys, and mfa status, then download and view the csv for compliance.

Explore Amazon EC2 core features, virtualization concepts, and how scalable, configurable virtual servers power AWS compute, with AMIs for Linux and Windows deployments.

Discover AWS EC2 instance types, AMIs, and configurations for CPU, memory, and storage (instance store and EBS), plus SSH access, security groups, elastic IPs, ELB, and ASG.

Explore how amazon machine images relate to ec2 instance types, compare general purpose, compute optimized, memory optimized, and storage optimized categories, and learn scalable upgrade paths on aws.

Explore Amazon machine images (amis) and how they power EC2 deployments, detailing EBS-backed and instance-store AMIs, launch permissions, block device mappings, and AWS Marketplace, community, and custom AMIs.

Create an IAM user with programmatic and AWS management console access, grant administrator permissions, securely save access keys, and sign in to access the EC2 dashboard.

Explore the Amazon EC2 dashboard, navigate instances, images, Elastic Block Store, and networks and security, and learn to launch and manage an EC2 instance across regions and availability zones.

Launch a free-tier EC2 t2 micro instance using the Amazon Linux 2 AMI, enable Apache via user data, and deploy a simple web page.

Configure security groups to enable SSH and HTTP for an EC2 instance, then create a key pair, launch the instance, and monitor its status from pending to running.

Explore the EC2 dashboard to view instance details, including id, state, type, and public and private IPv4 addresses, and learn how elastic IPs prevent changes after stop and start.

Explore elastic IPs in AWS, learn how they're associated or disassociated with EC2, transferred within a region, and used for zero-downtime switches with DNS domain records.

Allocate and attach elastic IP to an EC2 instance, verify association in the instance summary, keep IP reserved, and ensure only one elastic IP is attached over HTTP.

Explore basic EC2 administrative options to launch, stop, reboot, and terminate instances, keep data on persistent volumes, and manage elastic IPs to preserve or release public addresses.

Create and manage launch templates to deploy EC2 instances from saved configurations, preserving instance type, network settings, storage, and user data, with versioned templates for flexibility.

Create a new IAM user named Sam with programmatic and console access. Attach an inline JSON policy to Sam, review the policy name, and explore AWS sample policies.

Explore IAM roles in detail, contrasting them with IAM users and groups, and learn when to use roles for temporary credentials and cross-account, application, and mobile access.

Learn to create an IAM role for EC2 to read and write objects in S3, using AWS service as trusted entity and attaching the Amazon S3 Full access policy.

Define security groups as AWS firewalls that control inbound and outbound traffic for VPC instances, including up to five security groups per instance, rules, defaults, and authorize or revoke actions.

Explore security groups in the AWS console, view inbound and outbound rules, and create, edit, and delete groups for a secure VPC with SSH, http, and https access.

Discover how secure shell (ssh) enables remote administration of EC2 instances via command lines, across Mac, Linux, and Windows clients, with secure file transfer and remote task execution.

Learn to install Putty on Windows, convert a PEM key to PPK with Putty Gen, and connect to an AWS EC2 instance as EC2-user using SSH, then run basic commands.

Connect to an EC2 instance via the web-based EC2 instance connect client in your browser. Use the ec2-user on Amazon Linux 2 to run update and upgrade commands.

Explore AWS storage options, including EBS, EFS, S3, and Glacier, and compare their latency, cost, and archiving capabilities for different project needs.

Compare AWS storage types: S3 object storage, EBS block storage, and EFS file storage, focusing on pricing, durability, availability, performance, interfaces, backups, and use cases.

Explore Amazon elastic block store (ebs) for ec2, including block-level storage, persistence, and encryption. Compare gp2 and io1 types with performance metrics.

Learn a hands-on overview of Amazon EBS by launching an EC2 instance with an Ubuntu 20.04 LTS AMI, configuring GP2 volumes, security groups, and key pairs.

Manage Amazon Elastic Block Store volumes through the EC2 console by attaching and detaching root and secondary volumes, viewing details, and modifying or deleting volumes.

Explore EBS snapshots stored in Amazon S3; learn they are incremental backups saving only changed blocks and that a snapshot-derived volume begins as an exact replica across zones or regions.

Create and name an EBS snapshot, review its status, then create a volume from the snapshot, delete volumes as needed, and manage sharing permissions.

Explore Amazon machine images, learn to create an AMI from an existing instance, and launch new instances from it across regions, using AWS Marketplace AMIs, Community AMIs, or My AMIs.

Launch and customize an EC2 instance in us-east-1, create an AMI with root-volume EBS snapshots, and launch more instances from the saved AMI while using user data to install httpd.

Create an AMI from an EC2 instance, customize the Apache page on the image, then launch new instances from the AMI using the same key pair and security group.

Explore AWS EC2 Image Builder, a tool that streamlines building, securing, testing, and deploying up-to-date VM and container images for AWS or on premises, with built-in validation and policy enforcement.

Explore building an EC2 image pipeline with image recipes, infrastructure and distribution settings, and a custom IAM role, using Amazon Linux 2 EMI plus CloudWatch Agent and AWS CLI.

Continue working with the EC2 image builder pipeline to build, test, distribute, and integrate a final ami in us-east-1, launch an instance to verify aws cli v2 and openjdk corretto.

Explore Amazon Elastic File System (EFS), a scalable, shared file system for multiple EC2 instances, with durable, secure, low-latency storage across AZs and multiple storage classes.

Launch an Ubuntu 20.04 EC2 instance, create a new key pair, and configure a security group for HTTP and NFS to prepare mounting an elastic file system.

Create and configure an elastic file system (EFS), attach it to an Ubuntu EC2 instance, and mount via DNS and the NFS client to enable shared storage.

Mount an elastic file system to an Ubuntu 20.04 EC2 instance with the NFS client, create an EFS directory, set permissions, install nfs-common, and verify the mount.

Learn to upload files to a mounted EFS on an AWS EC2 instance using Cyberduck via SFTP, verify permissions, and create a test file to confirm the upload.

Learn to automatically attach an elastic file system to an ec2 instance during deployment and access the same efs from two instances, enabling shared files without manual mounting.

Terminate active EC2 instances and delete non-default security groups and the EFS file system to clean up resources, then refresh the console to reflect changes.

Explore how AWS provisions highly available, scalable resources with elastic load balancers, auto scaling groups, and Route 53. Distinguish vertical and horizontal scaling, including scaling up, down, out, and in.

Explore high availability and elasticity in AWS, including data redundancy across multiple availability zones, auto scaling, and elastic load balancing to keep applications resilient and scalable.

Explore how elastic load balancers distribute traffic across healthy EC2 targets using listeners and target groups, perform health checks, and support application load balancers for HTTP and HTTPS requests.

Discover how auto scaling groups dynamically manage EC2 instances with a load balancer, scaling out and in to meet demand with health checks, launch templates, and CloudWatch metrics.

Create a custom AMI from an Ubuntu 20.04 server with Apache, configure an auto scaling group launch template, and attach an elastic load balancer to distribute traffic.

Deploy an application load balancer to distribute http traffic on port 80 across two EC2 instances via a single endpoint, with target groups and health checks for fault tolerance.

Create a launch template for an auto scaling group by configuring the AMI, instance type, key pair, and security groups, then review, save, and view template details.

Automate EC2 scaling with an auto scaling group integrated with the application load balancer to deploy or terminate instances between four and six across six availability zones based on traffic.

Explore manual auto scaling as a foundation for AWS auto scaling groups, adjusting desired capacity and min/max, attaching to ELB, and safely detaching or terminating instances.

Explore dynamic scaling within an auto scaling group using target tracking and step and simple policies. Monitor CPU utilization with CloudWatch and keep ELB target group capacity balanced.

Examine dynamic step scaling and simple scaling, using cloudwatch alarms to trigger auto scaling based on CPU thresholds and define step adjustments in the AWS console.

Learn how predictive scaling in AWS auto scaling groups uses historical data to forecast hourly load, and how to create a PSC policy in a hands-on demo.

Explore scheduled scaling policies that auto scale EC2 instances on predictable load changes; the hands-on demo guides creating scheduled actions in an auto scaling group, configuring capacity, recurrence, and timing.

Explore amazon vpc foundations, route 53 dns, and internet routing within aws. Deploy and inspect an ec2 instance across public and private subnets to learn ip addressing and dns routing.

Discover how DNS translates domain names into IP addresses and how Amazon Route 53 routes traffic to AWS infrastructure such as EC2, load balancers, or S3, and even outside AWS.

Register and manage a domain with Amazon Route 53, create a hosted zone, route traffic to AWS resources, and monitor health through DNS checks.

Navigate the domain dashboard and hosted zones in Route 53 to review privacy, expiration, and transfer lock. Learn DNS records like A, AAAA, CNAME, MX, TXT to route traffic.

configure a Route 53 hosted zone to route traffic to an EC2 instance with an A record for the IP and a CNAME for www, then verify via hard refresh.

Clean up your AWS account by terminating the EC2 instance, deleting the A and CNAME records, removing the load balancer, and deleting any remaining EBS volumes to avoid charges.

Identify essential skills for this AWS & React course, including basic JavaScript (arrow functions, destructuring) and CSS (classes, selectors), plus a strong desire to learn.

Explore React, a lightweight JavaScript library for building user interfaces with a virtual DOM, maintained by Facebook, enabling a vast ecosystem of libraries for web apps.

Begin with a hands-on welcome to React, creating an index.html and rendering a hello world into a root div using ReactDOM from a CDN.

Install NodeJS and a code editor to begin React development; Visual Studio Code is free and runs on Windows, Mac, and Linux, with Sublime as another editor option.

Use CodePen for rapid React development with HTML, CSS, and JavaScript panels and a live preview; import dependencies in settings and enable Babel to render HTML in JavaScript.

Explore JSX as a concise way to embed HTML in JavaScript, learn how Babel translates features for browser compatibility, and use curly braces to run JavaScript expressions in React.

Build a bare-bones e-commerce app with a product list, view details, add to basket, dynamic cart updates, delete items, clear basket, and a simple checkout form to confirm orders.

Bootstraps a mini e-commerce project with Create React App, introduces a rest API via JSON Server, and guides installing and running the server with watch mode.

set up a json server as a mock rest api, create a db.json with categories and products, run on port 3001, and test endpoints like /categories and /products.

Learn to use the fetch API to pull JSON data from a JSON server, store it with a state hook, and render categories in a React app with map.

Style the store layout by adding a left categories list, header, footer, and main area, using the course-provided css and react fragments; fetch and display products for a selected category.

Convert the category list into a dedicated category component, destructure props, render categories with map (ensuring keys), implement api call to a JSON server, and compare a for loop alternative.

Make categories clickable with an onClick handler that passes the category id to fetch products from the JSON server, manage product state, render products, and add error handling.

Refactor fetch calls into a separate fetcher utility and use async/await in useEffect to fetch categories and products from the JSON server, using a reusable base URL.

Wrap the fetcher in a try/catch to return a response with an error message and data. Update the app to display category and product fetch errors and expose getCategories and getProducts for centralized URLs.

Enhance fetch error handling by checking response status and throwing an http error for 404, then surface a clear message to the caller while testing with the json server.

Style a three-column product list with CSS grid, featuring image, features, and price, using assets and a React category product component.

Install and wire up React Router version six to enable client-side routing, then wrap the app with browser router and define routes for home and product detail pages.

Fix the key warning in a React app by adding unique keys to mapped lists, using product IDs for products, and an index-based key for features.

Implement a product detail view with React Router dynamic routes and links. Use the view product button and navigate hook to route by product id.

Read the product id from the route with the use params hook, fetch the product by id via get product by ID, store it in state, and render the title.

Enhance the product detail page by fetching the product by ID, displaying image, title, specs, features, price, stock, and description in a three-column layout with React styled components.

Discover how styled components encapsulate CSS inside React components via tagged template literals, install with npm, and create styles like product title and image container with dynamic props.

Use styled components to separate css, create a description spanning three columns with a css grid, and fix the React Router layout that hides header and footer.

Explore the dangerously set inner HTML attribute in React to safely render HTML from descriptions. Learn how to create a markup function, handle HTML injection risks, and apply bold styling.

Refactor the categories feature by converting category links to React Router links, using URL params to fetch products by category, and updating routes to render category-specific products while preserving layout.

Refactor the React e-commerce layout using a dedicated layout component and outlet from react-router-dom, reorganizing routes and passing category data to render dynamic category pages.

Refactor home page by moving routing from index.js to app.js, using a layout component, and pass categories via props to the home route and footer links to basket and home.

Learn to implement a React context-based cart to share state across components, including creating a cart context provider, initial state, and add-to-basket interactions.

Build and wire a cart context with use context and use reducer to add products to the cart, dispatch actions, and manage cart items.

Extend the cart reducer with add, remove, increase, decrease, and clear, expose them via the cart context, and implement the basket layout with styled components and a checkout button.

Implement basket functionality by retrieving items from the cart context and rendering each item with its title, quantity, and price. Add controls to adjust quantity or remove items.

Import and place home, up, down, cart, and trash icons in a React e-commerce app, wire click handlers for checkout, clear basket, and quantity controls, and update the running total.

Style the header and footer links white. Add header with home and cart icons linked to home and basket pages; place total and button after the table; compute with reduce.

Finish the checkout by adding user input and validation on the checkout page, and persist the shopping basket across page refreshes and browser restarts.

Learn to fix the shopping basket by using local state and useEffect to refresh the cart from context, safely update quantities, and avoid direct array mutations.

Build a checkout flow with name, email, and billing and shipping details, then navigate to an order confirmation page that displays a thanks for your order message.

Learn to persist a shopping cart across page refreshes and browser sessions using the web storage API, switching from session storage to local storage with get item and set item.

Implement a top search bar that updates the URL with the query, navigates to a search results page, fetches matching products via an API, and displays them.

Debounce the search API calls with a search term state and a half-second timeout using useEffect, while cleaning up and showing no results found when there are no matches.

Convert name, email, and shipping address inputs into React controlled components with useState, using a single onChange handler and an onSubmit form with placeholders and browser validation via required fields.

Build robust React form validation by checking name, email, and shipping address, disabling the confirm order button until all fields are filled, and preventing default submission to show visual cues.

Learn to provide visual form validation in React by marking required fields with asterisks and applying conditional red borders using styled components and an errors object.

Apply on blur validation in React to mark fields as touched and display red error indicators, updating a touched state object to show errors only after users leave a field.

Explore routing with react router and styling with styled components for a feature-rich store. Leverage context and hooks for shared state, local storage, API mocking, and debounced fetch.