Docker and Kubernetes - The Complete Developers Guide

Use a food-truck analogy to explain Docker, encapsulating the required tools and environment inside a portable container. Deliver the meal anywhere, regardless of the host kitchen.

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.

Learn how a dockerfile builds an image from a base node:alpine image, and distinguish images from containers while using docker hub's ready-made node images.

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.

Map your local port to the container’s port 3000 using docker run -p so the app runs in the container and loads at localhost:3000.

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.

Optimize docker builds by using a .dockerignore to exclude node modules, docker files, and package-lock.json, preventing unnecessary copies and speeding up npm install inside the container.

Explore how Docker builds images in layers and uses caching to speed workflows; learn optimization tricks like ordering package.json and code copies to minimize npm install runs.

build a go rest api by creating a dockerfile, running go mod download, launching the image tagged golang app on port 8080, while excluding instructions.md and dockerfile from the container.

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.

Deploy containerized apps across multiple clouds and locations with control plane, reducing latency and downtime while managing ssl, cli deployment, and a dashboard for dev, staging, and production.

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.

Run node as a separate api container and mongodb in its own container to achieve isolation, scalable inter-container communication in Docker and Kubernetes environments.

Walk through a starter node back end and react front end, exposing rest endpoints for todos with MongoDB via Mongoose, and learn the client-server flow before diving into Docker.

Pull a MongoDB image from Docker Hub to run a MongoDB container, showing how Docker pulls the image when missing and starts the container with optional removal using --rm.

Build and run a node app in a dockerized workflow by creating a dockerfile, building the to-do app image, and linking it to a MongoDB container while troubleshooting connection issues.

Explore connecting a node app inside a Docker container to a separate MongoDB container using port mapping to localhost:27017, and discuss production limitations and latency from a middleman.

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.

Connect multiple containers via a Docker network, enabling container-name based communication that automatically resolves to the correct IP, ensuring stable inter-container communication.

Dockerize the React app and connect it to the node backend on a shared network, using a node-based frontend Dockerfile and building the frontend image.

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.

Explain how client side rendering in a React app runs in the browser, and show exposing the node application through port mapping to enable the frontend to connect.

Learn how to optimize Docker workflows by using volumes and bind mounts to enable hot reloading for React and Node apps and ensure MongoDB data persists when containers restart.

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.

Explore how to configure multi-container apps with a docker compose yaml file, and master yaml basics—key value pairs, arrays, and indentation that define scope.

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.

Configure the backend container using Docker compose—build the backend image, set up bind mounts and port 8000, inject MongoDB credentials via env vars, and declare a depends_on MongoDB dependency.

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.

Learn to deploy a containerized application to AWS using ECS by building the image locally, pushing it to a registry, and configuring the cluster, task definition, and service.

Write a Dockerfile for a Nest.js boilerplate using Node.js 18 Alpine. Install dependencies, build the dist with npm run build, and run production via npm run start:prod, exposing port 80.

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.

Master identity and access management (IAM) to create a new user with programmatic access, assign granular permissions, configure credentials, and securely access the registry.

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.

Create an ECS cluster to configure services for running a containerised app on EC2, set up networking, and deploy a hello world app reachable over http.

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.

Create an ECS service in your cluster to run a task definition (hello world task) with one task, and explore rolling updates, bluegreen deployments, and security group configuration.

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.

Highlight the drawbacks of a manual deployment workflow, showing how changes waste engineering time, invite errors, and rely on repetitive steps that risk downtime.

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.

Enforce branch protection rules to require builds, tests, and approval before merging into main. Learn why direct pushes to main are blocked and why feature branches matter in production.

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 environment variable secrets by replacing sensitive references, trigger a new workflow, and demonstrate secret masking during deployment and the Docker build.

Fetch the task-definition.json, update the image field with the new image using jq, and push the changes via git in a GitHub Actions workflow.

Update the task definition with the new image tag, push the revised definition to AWS, and force redeploy the service to roll out the updated task version.

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.

Adopt blue-green deployment, the optimal solution, with a load balancer to achieve no downtime by routing traffic between two EC2 instances running containers.

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.

Use a multi-stage dockerfile to build a node front end with npm install and npm run build, then copy the build into an nginx final image served on port 80.

Illustrates the risk of data loss when MongoDB runs inside a container across multiple EC2 instances and suggests using an external MongoDB Atlas cluster for persistent data.

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.