Docker, Kubernetes & AWS: Real-World Deployment in 25 Days

Discover how docker resolves development and deployment challenges by installing docker desktop and running ubuntu and python containers. Compare virtual machines with docker containers and enable effortless version switching.

Explore how environment differences between development and production cause deployment issues, such as case-sensitive file paths and locale variations, and learn how containers enable reproducible setups.

Learn how a container creates an isolated, portable environment that bundles your app with all dependencies, including the OS, enabling lightweight, cloud-ready deployment across machines.

Install Docker Desktop to manage containers with a graphical interface. Follow the setup steps: verify download, enable Windows Subsystem for Linux, complete installation, and launch Docker Desktop for immediate use.

Launch your first Docker containers by running a hello-world image from the command line, demonstrating Docker Desktop, terminal access, and quick spins of Ubuntu and Node.js for deployment.

Docker Hub is the container registry hosting official pre-built images like ubuntu and fedora. Downloading images is free and requires no login to pull, but trust in official publishers matters.

Learn how Docker images are immutable, multi-layer packages built from base to application, and how to pull, inspect, and view their history using Docker image pool, history, inspect, and ls.

Explore how docker image tags let you run different versions, such as python:latest or python:2, and how the repository and image concepts treat tags.

Understand how docker run serves as a shortcut for docker container run, downloads the image, creates and starts a container, and often runs it interactively with -it.

Explore this Linux crash course chapter and sharpen terminal skills for the upcoming quiz. Answer no to watch the crash course and refresh skills you'll need throughout the course.

Master linux shell commands for pwd, cd, ls, and navigating directories. Apply these basics in a docker ubuntu container with apt update and apt install, and run neofetch.

learn to run a web server inside a docker container, access it, and operate in detached mode, then manage, stop/start, inspect containers, and debug with logs and an interactive shell.

Explore ip addresses and port numbers, including ipv4 and ipv6, ip:port notation, localhost 127.0.0.1, and default ports like http 80, https 443, or ssh 22.

Learn how a web server delivers content over the internet by handling HTTP requests and responses between a browser and nginx, with HTTP 1.1 and HTTP/2 details.

Publish a host port to a container port when running nginx with docker run -p, then access the web server at localhost:8888 mapped to container port 80.

Run a container in detached mode with docker run -d to keep the main process running in the background, then use docker container logs to debug.

Display container information with docker container ls, including all containers (-a) and sizes (-s). Inspect and monitor containers using docker container stats and docker container inspect.

Learn to name containers with the --name flag and access them by name via docker container ls. Maintain name uniqueness, understand container states, and rename named containers.

Learn how to stop, start, and remove containers with Docker commands, manage running versus stopped states, and delete multiple containers efficiently using shell expansion.

Run docker containers that delete automatically by using docker run --rm, which removes the container when it stops, leaving no stopped containers behind.

Override a container's default command with docker run to launch a custom program, such as bash in a Python image to install numpy and run code.

Debug a running container by using docker container exec to run additional programs, either interactively with bash via -it or non-interactively, and install tools like numpy or pandas as needed.

Configure a container during Docker container create to attach a terminal (-t), enable interactivity (-i), and predefine ports, mounts, and environment variables before startup.

Launch an NGINX container and edit the index.html in its document root to show a light gray background and 'welcome to nginx in Docker', then expose the port.

Learn to use the nano text editor on the command line to create, edit, save with ctrl+o and quit with ctrl+x, and view files with cat in a Linux container.

Change the nginx start page by launching a docker container with port mapping, editing index.html inside the container with nano, and verifying the updated welcome page in the browser.

Learn to deploy Docker on an AWS Ubuntu server, run an Apache web server, install and manage software, connect via SSH, and ensure containers boot reliably for production deployments.

Learn how AWS and EC2 enable scalable cloud hosting for Docker, including EC2 instances, regions, and IAM, and compare running Docker on AWS, a virtual machine, or a Raspberry Pi.

Explore where to deploy Docker stacks across AWS, Raspberry Pi, and virtual machines, comparing cloud, hardware, and virtualization options, with guidance to start on AWS and test locally.

Learn how ssh secures remote access by using a client and server, configure key-based authentication with ed25519 keys, and connect to AWS, Raspberry Pi, or a virtual machine.

Sign up for a cloud account by verifying your email with a code, creating a root password, entering contact and billing info, completing identity checks, and accessing the management console.

Explore the AWS dashboard by learning how the account dropdown, region selection, and service list shape your view, with a focus on EC2 and S3 basics.

Launch and connect to an AWS EC2 Ubuntu instance by selecting the Paris region, importing a key pair, and opening SSH, HTTP, and HTTPS in the security group.

Prevent unexpected costs by using billing and cost management, cost explorer, and cost anomaly detection to monitor storage, SageMaker, and EC2, and learn to turn off unused resources.

Stop an EC2 instance and learn that its IP is released when stopped, incurring cost implications. Compare stopping, rebooting, and terminating, including data loss on termination and EBS storage.

Follow a practical EC2 troubleshooting guide to diagnose and fix connection issues, including region, IP changes, key pairs, and security group rules.

Learn how Linux user roles work, including regular users with their own home directories, system accounts, and the super user, and how sudo elevates privileges to access root.

Keep the linux server up to date using centralized package management with apt, handling repositories, dependencies, updates, dist upgrades, kernel upgrades, reboots, and occasional held back packages.

Demonstrates installing software on a server using apt, illustrated by cowsay. Covers removing packages and using apt autoremove to recover from upgrade issues.

Explore Docker architecture, including the Docker client and daemon, Docker host and Engine, containers, images, registry, and the Docker API.

Learn to install the docker engine on a remote server, address outdated repos, and choose between manual install or the get.docker.com script; then run a hello world container with sudo.

Launches an apache web server in a docker container using the httpd image, and maps port 80. Edit the container's /usr/local/apache2/htdocs/index.html to customize the page.

Learn how to configure Docker restart policies to keep web servers available after host reboots, using on-failure, always, and unless-stopped with docker run or docker update.

Learn to self-host by running docker on your own server or a Raspberry Pi, using a virtual machine as a placeholder. An optional chapter compares self-hosting with AWS deployments.

Set up a Raspberry Pi to run Docker by installing Raspberry Pi OS on a microSD card with Raspberry Pi Imager, enabling SSH and Wi-Fi for headless access.

Set up VirtualBox to run Ubuntu Server inside your host computer, and learn how to create a virtual machine, install Ubuntu Server, and enable OpenSSH access for remote management.

Configure VirtualBox networking for an Ubuntu server using bridged adapters instead of NAT to expose it on the home network, then connect via SSH by IP address.

Configure ssh key authentication on a Ubuntu virtual machine, add the public key to authorized_keys, disable password and root logins, and restart ssh to secure access.

Discover how Docker stores files in a container and how to move them with docker cp. Compare bind mounts with host access and use -v to launch a web server.

Explore how files are stored in the container's writable layer, why images stay read-only, and how deviations from the image increase container size, affecting efficiency.

Learn how to copy files into and out of a container with docker cp, using host and container paths, and practical examples like program.py and the /app directory.

Bind mounts map a host directory to a container directory, so host changes appear instantly inside the container. Use complex syntax or the -v form with absolute paths.

Learn to use read-only bind mounts to prevent container writes to a host folder while keeping host changes visible in real time, using short form or mount syntax.

Compare Docker cp and bind mounts for production versus development, noting speed, explicit data propagation, and overhead to decide when to copy data into containers or mount from the host.

Use a bind mount in a Docker container to serve a development gym website with Nginx, so changes in the source update instantly at localhost:3000.

Use docker cp to copy website data into an nginx container for production, explain port mapping, writable layers, and why bind mounts differ from in-container data.

Transfer your locally developed website to a remote server using scp over ssh. Then copy it into the docker container's httpd/htdocs to serve the site.

Purchase a domain, connect it to your server, and enable https to deploy a public site. Domain costs about $3 per year and enables real-world deployment on AWS later.

Explore how the domain name system translates domain names into IP addresses, using browser, operating system, and resolver caches, and traverses root servers and TLDs.

Explore DNS records like A, CNAME, MX, TXT, and NS, and learn how to query them with the host command to see DNS resolution in action.

Purchase and configure a domain with Amazon Route 53, create A records for the root and www subdomain, and map them to your server while managing TTL and DNS propagation.

Enable https for your website by using a public domain and a server with dns pointing to it, then deploy with caddy to automate tls certificates and http3 support.

Configure a Caddyfile to serve https for www and non-www domains, enable gzip, deploy with docker using a bind mount, and point DNS to the server.

Stopping an EC2 instance releases its public IPv4 and disrupts domain DNS records, forcing updates to A records and IPv6 RR records and DNS propagation.

Diagnose AWS deployments by verifying domain resolution and nameserver alignment with the hosted zone; correct A records for root and www, then check SSH and HTTP/HTTPS security in default VPC.

Explore how AWS App Runner deploys Docker images and runs nginx, then learn to build your own images, like nginx with data or a NodeJS application, for deployment.

Discover how AWS App Runner provides a managed, scalable environment for stateless Docker containers, automatically handling load balancing and provisioning, while data remains stored outside the container.

Sign in to the AWS dashboard, navigate to App Runner, and launch a service from a public ECR nginx image, then configure port 80 and dual stack.

Transition from predefined images to crafting dockerfiles, learn how docker build turns dockerfiles into images, and prepare a custom nodejs app for publishing to a repository and deployment.

Learn how to build a Node.js server that serves a simple website, install dependencies with npm, run the app on port 3000, and prepare for dockerfile migration.

Create your first Docker file from a base node image, build and tag an image with Docker build, then run a container to verify the app.

Copy files in the build context to /app with copy; prefer copy over add, which handles archives or remote data but adds a layer. Run the app with node /app/bin/www.

Configure the container to run a default command with CMD, choose between exec form and shell form, and note that the last CMD takes effect.

Examine how the entrypoint differs from cmd and resists docker run overrides. Use entrypoint for standalone executables and cmd for web servers, with overrides applied to cmd.

Learn how to document container ports with the expose instruction and map host ports, using examples of 3000 and 80, and how -p versus -P work.

Use a dockerignore file to exclude files and folders from the build context, reducing image size and speeding up builds with wildcard patterns like node_modules and Dockerfile.

Use the run command in dockerfiles to execute setup tasks during build, chain commands with &&, install dependencies with apt-get -y, and bake image layers for faster scaling.

Learn how to set the working directory in the dockerfile using the workdir command, create directories, and run commands within an absolute path to streamline image builds and development workflows.

Optimize your development workflow by structuring dockerfile cache layers: copy only package.json and package-lock.json first, run npm install, then copy the rest to speed rebuilds and leverage image history.

Set up a private docker registry to store and share your images, enabling push from your development machine and pull by servers for deployment.

Explore x86 and arm64 cpu architectures, and learn how Docker builds and runs images for Raspberry Pi and AWS, using the platform flag and emulation trade-offs.

Launch a local docker registry, tag images for localhost:6000, push and pull between your host and registry, and manage port conflicts and container lifecycle.

Launch a private docker registry on a local network with a Raspberry Pi, then tag and push images, and configure insecure registries in Docker Desktop for http access.

Turn a remote server into your private registry, attach a domain, enable https encryption and password logins, stop existing containers, launch the registry, and manage port mappings and security settings.

Launch a private registry with https via Letsencrypt, configure with environment variables or a config file, then test push and pull over a 443 to 5000 port mapping.

Enable password protection for your docker registry with http basic authentication and an htpasswd file; configure realm and path, and use a docker httpd container for secure, private access.