Relate your code's environment to Docker containerization and learn how containers run apps in isolation with their dependencies for Linux and PostgreSQL deployments.

Build a small Node app using Express, defining package.json and index.js, exposing a hello world endpoint at localhost:3000, and run the app in a Docker container.

Learn to run a node express app locally by installing node, installing dependencies with npm, and starting the app on port 3000, with docker running later.

Create a Dockerfile in the app root to containerize a Node app. Define base image, workdir, copy files, install dependencies, expose port 3000, and run npm run start.

Understand the dockerfile by setting a base image and a working directory at /user/source/app, copying project files, installing dependencies, exposing port 3000, and starting with npm run start.

Build a Docker image from your Dockerfile, tag it for easy identification, then run a container from that image to expose port 3000 and verify with the Docker CLI.

Learn to rebuild docker images and restart containers to reflect code updates, manage port mappings, and use volumes or bind mounts to sync host files with container work directories.

Learn how to sync local files into a docker container using a bind mount with -v, mapping absolute paths to the container’s working directory, including Mac and Windows caveats.

Learn to use an anonymous volume to keep node_modules intact during bind mounts, preserving dependencies for the Express app and enabling running on port 3000 inside the container.

Docker isn't the culprit; Node and Express require restarts for changes. Enable dev hot reload with nodemon, build a Dockerfile dev, and run with proper port mappings and mounts.

Learn to build a Golang rest API Docker image using a Golang alpine base, optimize caching with go mod download, expose port 80, and run and test a detached container.

Explore how to deploy an application across multiple cloud providers and locations using a global virtual cloud (GVC) in the control plane, and prepare your app image for deployment.

Build a local image, log in to a private control plane repository, tag it with the organization registry format, push it, and run it as a workload to deploy containers.

Pull your private image and deploy a node app workload on port 3000, then monitor deployment status across locations and test the endpoint with Postman.

Stop all deployments on Google Cloud Platform to prevent further costs, then delete the workloads to remove resources and ensure services terminate.

Docker and Kubernetes course overview: dockerize a simple to-do app with a React frontend, a Node backend, and a MongoDB database, demonstrating frontend–backend–database communication and data persistence.

Connect the node container to the MongoDB container directly using the MongoDB container's IP address, and examine IP volatility issues to guide toward the ultimate solution.

Run a Docker container for the front end, map ports to access React locally, and troubleshoot Axios errors where the frontend cannot reach the Node backend or MongoDB endpoint.

Explore how Docker Compose simplifies deploying multi-container apps. Replace lengthy Docker run commands for MongoDB, Node API, and React app with Docker Compose up and a YAML file.

Write a Docker Compose YAML to spin up a MongoDB container with a named volume for data, covering image, version 3.8, services, and environment variables.

Configure a MongoDB container in Docker Compose with a username and password by using environment variables or an env_file, enabling authentication and restricting access.

Run a MongoDB container with docker compose up, verify status using docker ps, and then tear down with docker compose down to remove volumes and reset the container name.

Test the integration by restarting docker compose, connecting to MongoDB on port 8000, and using Postman to create, fetch, update, and delete todos at localhost:8000/todos.

Configure the frontend docker container with docker compose, map port 3000, and connect to the backend and MongoDB; use volumes to link local source and run the dev server.

Build a docker image tagged Hello World App, then run it with port mapping to expose localhost port 80 and verify the app serves hello world.

Push the locally built image to aws elastic container registry in the us, using the repository named hello world repository with the latest tag, and follow login and push steps.

Learn how to build a docker image, tag it for the correct repository, and push it to a docker hub registry, verifying tags along the way.

Define a task definition that mirrors a docker run command, specifying the container, image, memory, CPU, and port 4040 mapping to run a hello world container on an EC2 instance.

Configure the inbound rules of the default security group to allow web traffic to an EC2 instance on port 80 and enable port mapping to forward to the container.

Redeploy changes by rebuilding the Docker image, pushing it to the registry, creating a new task definition, and updating the ECS service to run the new image.

Automate your deployment workflow with CI/CD tools, focusing on GitHub Actions. Learn to replace manual processes with automated pipelines usable across Circle CI, Travis CI, Jenkins, and TeamCity.

Push your code from the local machine to GitHub, use main as the source of truth and feature branches with pull requests, and automate builds, tests, and deployment through CI/CD.

Push your local code to a private GitHub repository by initializing a git repo, configuring the main branch, linking the remote origin, and pushing commits for the first pipeline workflow.

Create a new branch from main, commit and push changes, and open a pull request to merge into main. Use GitHub actions to run the build and tests for success.

Create a GitHub Actions deployment workflow triggered by main branch merges to deploy a containerised app to AWS, using repository secrets for credentials.

Build a docker image from the repository, tag it with the GitHub sha, and push to the AWS ACR registry using a GitHub actions workflow with secrets.

Fix deployment issues by updating the service and setting minimum healthy percentage to zero, tearing down old containers, and deploying the new image through the CI pipeline on ECS cluster.

Identify the major deployment flaw that causes downtime when switching from the old container to the new one, highlighting the gap between tearing down and starting the new image.

To avoid ongoing costs, tear down the ecs cluster by deleting the hello world cluster, de-registering task definitions, and cleaning up the ec2 instance, service, and running tasks.

Learn how to deploy a multi-container application to Amazon X, building on the one-container deployment and adapting React, Node, and MongoDB containers for production readiness.

Explore why the React development server is not suitable for production, and learn to build a production front end with npm run build and Engine X to serve build directory.

Rebuild the front-end and back-end images, create repositories, and push the images to the registry. Prepare a back-end Dockerfile with node 18 alpine, port 8000, and start: prod.

Define a multi-container task definition in ecs on ec2 with two containers, backend and frontend, mapping 8000 and 80, then deploy a service.

Hide sensitive data behind environment variables by moving the mongo uri and frontend urls into process.env, define them in the task definition, and tag images as v2 before pushing.

Update the task definition to version two, set the mongo uri and backend url as environment variables, and redeploy the service to launch the new task.