Build Node.js apps with AWS DynamoDB & Docker containers

Reorganize a Node.js Express project by creating controllers and routes folders, separating controllers from routes, and moving logic from the entry point.

Learn to structure a Node.js app by moving the hello world controller into its own file, exporting the function, and importing it in index for cleaner, scalable controller organization.

Apply the same controller reorganization to all files, move logic into dedicated files, clarifying endpoints (get, put, post) and routes, and ensure per-controller fs imports.

Create a dedicated express router file and move to-do routes into it, wiring controllers with proper relative imports to separate routing from application logic for easier maintenance.

Conclude the project reorganization by preparing to connect a database to the project and replace local json storage with a folder structure that maps database objects to code.

Explore DynamoDB, a fast, flexible NoSQL service with a cost-effective free tier and single-digit millisecond performance. Learn to run it locally with Docker for fully managed DynamoDB in Node.js apps.

Install exact versions of the Atrius SDK and Dinamo DB data mapper in a Node.js project, using npm install --save to update package.json and ensure consistent dependencies across environments.

Learn to run a local DynamoDB instance with Docker, using a provided command to start the service and a graphical library to monitor its local data.

Install a visual tool to inspect your locally hosted DynamoDB, using the DynamoDB admin dashboard to visualize tables, create a sample food table, and prepare for production with AWS-hosted DynamoDB.

Learn to configure a Node.js app to connect to DynamoDB with the AWS SDK and data mapper, switching automatically between a local DynamoDB instance and production.

Explore how environment variables on Linux, macOS, and other operating systems guide Node.js apps by distinguishing development and production settings and selecting appropriate credentials.

Finish configuring the DynamoDB connection by adding a local endpoint and placeholder access and secret keys, then remove the endpoint for production and recover production credentials later.

Develop a DynamoDB client by initializing a client with a config, creating a data mapper, and exporting the mapper for use in Node.js applications.

Explore the DynamoDB data mapper, a tool for Node.js that lets you access database objects without writing queries, enabling natural JavaScript code to fetch items like to-dos.

Create a DynamoDB table named to-dos to store your to-do items, configure the hash key, optionally include a range key, and leave read/write capacity at default.

Understand how DynamoDB uses an index to efficiently query items, mirroring a book index, and learn to index the id field to retrieve todos by id.

Insert a todo item into DynamoDB by mapping a name to the ID, save and update the item, and manage the table by viewing counts and deleting to reset.

Create a to-do model in code using a JavaScript object and a DynamoDB data mapper, defining the table and fields to map native objects to DynamoDB queries.

Import the DynamoDB client and to-do model, create a new to-do with a name and complete flag. Insert it using the mapper and verify with Postman.

Debug and fix DynamoDB connection by setting the environment variable during npm start, clarifying development versus production credentials, and validating local DynamoDB integration.

Explains how promises manage asynchronous database operations with a DynamoDB mapper, using then for success and catch for errors, and shows returning a 500 error on failure.

Explore how HTTP status codes indicate client versus server errors, and see how DynamoDB schemas, key schema, and payload validation influence responses and status codes in a Node.js app.

Generate unique IDs for each todo with UUID v4, replace sequential IDs, and ensure the DynamoDB key schema enforces uniqueness, wiring the name from the request and testing with Postman.

Implement a get todo controller in a Node.js DynamoDB app, using scan with the only pending query parameter to filter complete=false, then log items and return an ok response.

Install nodemon as a development dependency to auto restart the server on code changes and update the start script to use nodemon, keeping it out of production.

Store dynamo collection query results in an in-memory tattoos array and push resolved items. Send tattoos as a json message representing the to do list and show only pending items.

Discover two approaches to filtering completed todos in a Node.js app with DynamoDB, and implement the correct method that returns only pending items when show=only pending.

Replace the old in-memory update logic with a DynamoDB-backed endpoint, using async to fetch the todo by id and update it in the DynamoDB table via the new todo model.

Explore async/await as a cleaner alternative to .then().catch for handling promises in a to-do app. Learn how try/catch and await improve readability when fetching data from a database.

Finish the update ToDo code by setting the todo's complete to true and performing a put update, handling status codes like 500 with try/catch and returning a JSON response.

Explore a better way to organise try/catch blocks to reduce indentation. Move code outside the first try block to improve readability and maintainability, addressing unresolved variables.

Explore const and let variable scopes in JavaScript, showing block-level visibility, immutability of const, and when to use let for assignments inside and outside blocks.

Implement sending a success response by returning the response status, keeping the code readable and concise, and then test the code.

Fix the URL params in our router by correctly defining the expected parameter name with a colon, ensuring Express recognizes the URL parameter.

Deploy a backend for a DynamoDB-based to-do app, demonstrating item retrieval, creation, and update with async/await, tested via Postman, with production deployment and auto-scaling setup.

Learn how to dockerize a Node.js app and deploy it with Atrius Farm Gate, exposing port 50000 and using pm2-runtime for production readiness.

Create a new container registry repository, build and tag a Docker image, and push it to AWS Elastic Container Registry; then set up the Elastic Container Service cluster.

Configure a custom domain name by mapping a subdomain via Route 53 to your application load balancer, using alias and region settings to keep traffic transparent to users.

Enable auto scaling for the Stargate cluster by configuring min, desired, and max tasks, then choose a step tracking policy to govern scale in and out.

Use target tracking to auto scale based on metrics like average CPU utilization, memory, or requests per target, keeping load under a set value such as 20 percent.

Master step scaling and target tracking in auto scaling by configuring CPU utilization alarms, one-minute thresholds, cooldowns, and scale-out and scale-in policies to respond to load spikes.