Docker & Kubernetes: The Practical Guide

Explore the core Docker concepts of images and containers. Learn how images relate to containers and how to create, run, and manage pre-built and custom images in this module.

Learn how images serve as blueprints for containers, containing code and tools, while containers run those images as multiple instances across machines.

Learn how to use pre-built images with Docker, pulling official node images from Docker Hub, running containers with docker run, and exposing interactive shells while recognizing container isolation.

Learn to build a custom Docker image by layering a Node.js app on a base image, then run it in a container and manage dependencies with package.json and npm.

Build a custom docker image by writing a dockerfile with from node, copying files to /app, setting workdir, running npm install, exposing port 80, and using CMD for container startup.

Build a custom image from a Dockerfile, then run a container with docker run and publish ports using -p to access the app locally.

Build and run a custom Docker image from a Dockerfile, then learn that images are read-only; to reflect code changes you must rebuild the image and restart the container.

Learn how Docker images are built as layer-based caches, where only changed layers re-run, and how placing package.json before copying code optimizes npm install using cache.

Docker uses images as blueprints for containers that run your code and its environment, with dockerfile instructions, base images, dependencies, and port configuration.

Configure and manage Docker images and containers, including tagging, listing, inspecting, and removing images, and naming, configuring, restarting, and removing containers, with dash-dash-help guiding options.

Learn to manage docker images and containers with docker ps to list running and stopped containers. Restart a stopped container using docker start and verify the app on localhost 3000.

Understand how to run docker containers in attached and detached modes, compare docker run, docker start, and docker ps, and use docker logs and docker attach to access running output.

Dockerize a Python app with a Python base image, copy the code, and run a command. Use interactive mode (-i -t) to input data and compare attached vs detached containers.

Learn to manage docker images and containers by stopping and removing unused containers, deleting images with docker rm and docker rmi, and pruning unused images to keep your environment lean.

Explore how the Docker run command exposes and manages containers, focusing on the --rm flag to automatically remove a container when it exits, preventing leftover stopped containers.

Explore how docker images encapsulate code and environment, how containers share layers, and how docker image inspect reveals id, created date, ports, environment variables, and entry point.

Master the docker cp command to copy files or folders between a running container and the host, and learn when this is useful for config files or logs.

Learn to name containers with --name and tag images with repository:tag, enabling easier management and versioned reuse across runs.

Use Docker to package dependencies into images and run containers without global installs. Share images via Dockerfile or finished images and deploy from the official node image.

Push built images to Docker Hub or private registries using docker push, tagging, and docker login, while managing public or private repositories and access for teammates.

Pull and run shared Docker images from Docker Hub, including public ones. Docker pull fetches the latest image; Docker run won't update a local image unless you pull first.

Explore how images act as templates for containers, how layers optimize builds, and how to create, run, and manage images and containers with docker run and docker build.

Explore how to manage data inside images and containers beyond code storage by using volumes and connecting to folders. Learn how arguments and environment variables influence Docker images and containers.

Identify data categories in Docker workflows, from read-only code in images to temporary container data and permanent data stored with volumes, highlighting why volumes preserve persistence.

Analyze a real node express app and dockerize it, showing how a feedback form stores data in a temp file before copying to a final feedback folder.

Dockerize the app by creating a node-based dockerfile, building and running a container, exposing port 3000, and understanding isolated file systems and image snapshots.

Understand how Docker containers add a read-write layer to a read-only image, isolating each container but risking data loss when a container is removed.

Discover how Docker volumes map folders from the host machine into containers to persist data. Learn how volumes survive container removal and enable read-write access between host and container.

Add a Docker volume instruction to map /app/feedback to the host, build and run the container, and fix cross-device rename errors by swapping to copyFile with manual deletion, then rebuild.

Learn how named volumes persist data across container restarts by mapping app/feedback to a host volume with docker run -V, unlike anonymous volumes that vanish when the container stops.

Explore bind mounts to reflect live code changes in a running container by mapping a host folder to /app, enabling development and avoiding rebuilds compared with managed volumes.

Learn to combine docker volumes and bind mounts, and use anonymous volumes to protect node_modules, ensuring npm install survives and updates reflect without rebuilding.

Enable automatic node restarts inside a container by adding nodemon as a dev dependency, wiring npm start to run nodemon, updating the Dockerfile, and rebuilding the image.

Compare and explain anonymous volumes, named volumes, and bind mounts in docker run, highlighting how each behaves across container life cycles, data sharing, and host file system storage.

Set bind mounts to read-only with :ro to prevent container writes, keeping host edits. Use sub-volumes for writable folders like app/feedback and app/temp via docker run.

Explore how Docker manages volumes, including named and anonymous volumes, bind mounts, and common commands to create, inspect, remove, and prune volumes, with emphasis on data persistence across containers.

Compare copy in Dockerfile with bind mounts: use bind mounts for development to reflect changes instantly, and copy to create snapshot production images.

Learn how to use a .dockerignore file to restrict what the Dockerfile copies, preventing outdated node modules and speeding up image builds.

Learn how to use build-time arguments and runtime environment variables in Docker, including --build-arg, --env, and .env files to configure ports like PORT dynamically.

Explore build-time arguments (ARG) in dockerfiles to set default_port and other values, enabling flexible image builds from a single Dockerfile.

Explore how docker containers read and write data, and how named volumes, anonymous volumes, and bind mounts persist or expose data, with build arguments and runtime environment variables.

Explore Docker networks to connect multiple containers and enable inter-container communication. Learn to connect a containerized app to your host and reach the world wide web from inside the container.

Understand how a containerized app communicates with external web APIs over http, using axios in Node.js to fetch data from the Star Wars API, and ensure container network access.

Connect a dockerized app to a host machine service by communicating with a database on the host, such as MongoDB, from a Node.js demo application.

Explore container to container communication and cross-container networking in multi-container apps, and apply the one main thing per container principle with a note app talking to sequel database and MongoDB.

Explore a node-based demo app that dockerizes a web API, fetches data from the Star Wars dummy API, and stores favorites in MongoDB with mongoose via four endpoints.

Dockerize a node app, build and run a container named favorites-node on port 3000, exposing it to the web and illustrating host MongoDB remains outside the container.

Learn how a dockerized node app communicates with a locally installed MongoDB using the host.docker.internal domain. Rebuilds and restarts ensure container-to-host data access, verified by a local get request.

Learn to run a node api container alongside a MongoDB container, enable cross-container communication, inspect container addresses, and understand isolation, with a note on easier multi-container setups.

Explore docker networks that enable container-to-container communication by name within a shared network, using the --network option, without publishing ports.

Learn how Docker resolves IP addresses for outbound requests by using container names as domains within a shared network, and why Docker doesn’t modify your source code or browser requests.

Explore container communication and networks, learn to persist MongoDB data with volumes, and enable cross-container requests using networks and container names.

Learn to build a realistic multi-container application by combining multiple services, database, backend, and frontend, using Docker to coordinate containers and apply prior lessons.

Create a three-block app with a MongoDB database, a Node.js REST API backend, and a React frontend, then dockerize each service and persist data and logs.

Start a MongoDB container from the official image and name it MongoDB, running in detached mode. Expose port 27017 to the host so the backend can connect to the database.

Dockerize the node backend by writing a dockerfile, building a node image, and publishing port 80 so the React frontend talks to the backend and MongoDB using host.docker.internal.

Dockerize a React frontend by creating a Dockerfile based on Node, install dependencies, and run a development server on port 3000; learn container networking and multi-container setup.

Create a docker network named goals-net and attach mongodb, backend, and react containers for cross-container communication. Update code to use container names (mongodb, goals-backend) and publish ports for local access.

Learn how to persist MongoDB data in Docker using a named volume mapped to /data/db, and secure access with MongoINITDB root username and MongoINITDB root password, including authsource=admin.

Utilize volumes for logs and bind mounts for live code in the node backend, enable nodemon for automatic restarts, and secure credentials via environment variables with a .dockerignore file.

Bind the app source folder into the frontend container to enable live updates, and use a .dockerignore file to exclude node_modules and the Dockerfile, speeding up image builds.

Explore a three-service app using standalone containers that talk to each other and persist data, with live code updates, for a development-focused Docker setup.

Learn how Docker Compose simplifies multi-container setups by bringing up a three-container app with a node express api, a react frontend, and a mongodb database, using a single command.

Learn how Docker Compose replaces multiple docker build and run commands with a single file that defines services and configures ports, environment variables, volumes, and networks on one host.

Create a docker-compose.yml to define a multi-container project with backend, frontend, and mongodb services, locking in a compose version like 3.8 and using indentation to express dependencies.

Configure the mongo service in docker-compose.yaml by specifying the mongo image, a named data volume mounted at /data/db, and environment variables such as MONGO_INITDB_ROOT_USERNAME and MONGO_INITDB_ROOT_PASSWORD, or an env_file.

Start and manage multi-service apps with docker-compose up and down, building images, creating networks and volumes, and cleaning up with prune and the -v option.

Configure a backend service with docker-compose by building from a Dockerfile, publishing ports, mounting volumes, using env_file for mongodb credentials, and declaring depends_on to ensure mongodb starts first.

Learn to orchestrate a frontend and backend with docker-compose, using bind mounts, interactive mode, and smart rebuilds to run three containers on localhost:3000.

Learn how docker-compose builds and manages multi-container apps using up and build commands, force rebuilding with dash dash build, and customize container names for your services.

Docker compose simplifies multi-container projects and even single-container setups with a docker-compose.yaml, works with docker files, and partially replaces docker run and docker build.

Learn about utility containers, which provide environments like node.js or PHP. Start them with a command after the image name to perform specific tasks, not to run an app.

Explore utility containers in Docker and why they matter for bootstrapping projects. Learn how containers provide Node.js and npm environments without installing tools on your host.

Learn to run node containers in interactive and detached modes, override the default command with npm init via Docker exec, and work inside running containers.

Build a first utility container using a node 14-alpine image with a docker file, set a working directory, and enable bind-mount shared host folders for npm init.

Explore how entrypoint augments docker run by appending commands to a restricted npm container, enabling controlled npm init and install with bind mounts and work directory.

Learn to use docker compose to define and run services with a docker-compose.yml, build an npm service, configure bind mounts, and manage up, run, and down workflows with cleanup.

Demonstrate utility containers that run commands via Docker run and Docker Compose run, using bind mounts and configuration files to streamline local development with Laravel.

Build a Laravel PHP development environment from the ground up using Docker, Docker Compose, images, and containers.

Learn a docker-based target setup for Laravel development, using PHP interpreter and nginx containers with a MySQL database, plus composer, artisan, and npm tooling.

Set up a multi-container Laravel project with docker-compose, including nginx, php, mysql, composer, npm, and artisan services, with port 8000 to 80 and a read-only nginx.conf.

Build a custom php container using php:7.4-fpm-alpine, install pdo and pdo_mysql extensions, and configure a bind mount to /var/www/html for laravel projects.

Launch a MySQL container with the official image 5.7, configure database, user, and root password via an env file, and connect it to the PHP container on the same network.

Build a composer utility container from the composer base image, set a custom Dockerfile with an entrypoint using --ignore-platform-reqs, and bind your source directory to /var/www/html for Laravel setup.

Learn to create a level app using the composer utility container, run single containers with docker compose run --rm, and reflect the project in a bind-mounted source folder.

Target only the server, PHP, and MySQL services with docker-compose up, using depends_on to ensure PHP and MySQL start, and enable --build to refresh images.

Set up artisan container in docker compose to run level commands and migrate the database, override docker settings with docker compose, expose /var/www/html, and configure php and npm containers.

Compare using docker compose with or without dockerfiles, including entrypoint and working dir, and learn how bind mounts aid development but complicate deployment by keeping code outside the image.

Explore how to choose between bind mounts and copied snapshots in Docker and Docker Compose, configure nginx with default.conf, adjust build contexts, and prepare a Laravel app for deployment.

Deploy docker containers from local development to production on remote hosts, including single and multi-container apps across one or more servers. Compare self-managed and managed deployment options with AWS.

Explore how Docker containers create reproducible development and production environments, and learn deployment considerations from local host to remote servers, including build steps, bind mounts, and multi-container setups.

Learn a simple docker deployment: build a single-image node app, deploy to a remote server via ssh, push and pull the image, run the container, and expose ports.

Launch an EC2 instance, configure a VPC and security group, and connect via SSH to install Docker, pull a dockerized Node app, and run it, exposing port 80 for testing.

Expose latest code to a running container in development for instant updates with bind mounts, while production relies on copy to embed code in the image for a reproducible environment.

Learn how to build a Docker image and run a container on a remote AWS EC2 instance to deploy a demo application to a public web server.

Launch an EC2 instance with Amazon Linux AMI and t2 micro, create a key pair, and connect via SSH from Linux, macOS, or Windows to install Docker and run containers.

install docker on a remote amazon linux ec2 instance by updating packages, enabling amazon linux extras, starting the docker service, and running docker commands.

Push a locally built Docker image to the cloud by building locally, tagging, and pushing to Docker Hub, then pulling and running on the remote host.

Publish and run a dockerized app on an ec2 instance by deploying a container, exposing port 80, and securing access with security groups and ssh access.

Learn how to update a dockerized app by rebuilding and pushing a new image, pulling the latest version on a remote server, and restarting the container on an EC2 instance.

Evaluate the drawbacks of the do-it-yourself docker deployment on an EC2 instance, including security, maintenance, and networking responsibilities, and explore managed alternatives that let you focus on code.

Compare manual deployment with managed services, weighing trade-offs between control and responsibility versus ease, and explore AWS ECS for provider-managed container orchestration.

Deploy a node-demo container on AWS ECS using Fargate, mapping container port 80 to the outside world from a Docker Hub image, and learn ECS basics.

Clarify AWS basics, VPCs and subnets, and explain how AWS ECS with Fargate runs containers on demand, scales with auto scaling, and addresses production cost considerations.

Rebuild and tag the updated image, push to Docker Hub, then create a new ECS task revision and update the service so it pulls the latest image.

Deploy a two-container app to AWS ECS by building and pushing a backend image to Docker Hub, connecting to MongoDB, and using environment variables for cross-environment flexibility.

Configure a nodejs backend container on ecs fargate by creating a cluster, a task definition, and two containers (backend and mongodb) with production and development env variables.

Deploy a multi-container app on AWS ECS with Fargate by adding a MongoDB container, mapping port 27017 and environment variables, then expose via an application load balancer.

Set up an AWS load balancer for a stable domain, fix the health check path to /goals, and attach the correct security groups so ECS tasks remain reachable.

Discover how elastic file system (efs) volumes in ecs enable data persistence across deployments by mounting a shared volume to containers and updating services.

Run a nodejs rest api and a mongodb container on AWS ECS. Use an EFS volume for data and a load balancer that exposes a public URL and forwards requests.

Compare running your own database containers with managed services, addressing scaling, availability, backups, and security for MongoDB, relational databases, and cloud options like AWS RDS and MongoDB Atlas.

Move to MongoDB Atlas to run a cloud database in production and development using the free M0 sandbox on AWS, with a connection string and secured access via IP whitelisting.

Migrate from a MongoDB container to MongoDB Atlas in production on AWS ECS by updating the node API container credentials and production database name, and deploying a refreshed image.

Finalize a two-container architecture by deploying a React single-page app and a Node.js REST API to ECS, using MongoDB Atlas, and acknowledging the React build step.

Explains why front-end builds differ between development and production, showing how npm start and React scripts compile and transform browser code, and why production needs a separate build and server.

Create a build-only container by separating development and production Docker workflows: use a build step (npm run build) to generate optimized assets and a production server via multi-stage builds.

Learn to build with multi-stage dockerfiles: create optimized build artifacts in one stage, then copy them into a lightweight nginx stage, exposing port 80.

Learn to implement a multi-stage build, adjust code for AWS ECS, replace local host with slash goals, and push a production front end to Docker Hub for deployment.

Deploy a standalone frontend container on AWS ECS by creating a separate task and service, mapping port 80, and using environment-driven backend URLs via NODE_ENV for development vs production.

Explore how development differs from production in dockerized apps, using multi-stage builds and separate dockerfiles for each environment, while preserving reproducibility through consistent images and environments.

master multi-stage build targets in docker by using the dash dash target flag to build up to a chosen stage, enabling partial builds and flexible testing or running servers.

Explore the two deployment philosophies—self-managed Docker on a remote machine and using managed services like ECS—and learn how features translate across providers.

Explore how Docker containers enable local development and production deployment, build images, run containers, and deploy to AWS ECS with multistage builds, bind mounts, and managed databases.

Revisit Docker core concepts and clarify how running Docker locally on the local host differs from the tools that matter there, then review deployment concepts learned earlier.

Master how docker containers provide isolated, single-task environments built from images, with volumes persisting data and serving as blueprints for reproducible deployments.

Demonstrates core docker commands for images and containers: docker build with a Dockerfile and build context, tag and version images, run containers, and push or pull on Docker Hub.

Explore data persistence with bind mounts and volumes, including named and anonymous volumes, to keep container data beyond shutdown, and configure Docker networks for container-to-container communication using container names.

Discover how Docker Compose streamlines multi-container projects by defining containers, environment variables, volumes, and networks in a configuration file and using docker compose up and down.

Learn how Docker and containers enable isolated, reproducible development on your local machine and seamless deployment to remote hosts, with simple updates by replacing containers.

Deploy containerized apps with volumes over bind mounts and leverage multi-stage builds for production-ready images. Evaluate self-managed versus managed services to balance control, security, and deployment across hosts and Kubernetes.