Docker & Kubernetes: The Practical Guide
Welcome to the Course (2:32)
What Is Docker? (4:42)
Why Docker & Containers? (5:59)
Join Our Learning Community
Virtual Machines vs Docker Containers (8:55)
Docker Setup - Overview (4:31)
Docker Setup - macOS (3:33)
Docker Setup - Windows (9:44)
Docker Setup - Docker Toolbox for Older Systems (6:51)
An Overview of the Docker Tools (3:04)
Installing & Configuring an IDE (2:07)
Getting Our Hands Dirty! (9:23)
How To Get The Most Out Of This Course (3:24)
Docker Images & Containers: The Core Building Blocks
Images & Containers: What and Why? (2:29)
Using & Running External (Pre-Built) Images (8:28)
Our Goal: A NodeJS App (6:40)
Building our own Image with a Dockerfile (11:14)
Running a Container based on our own Image (7:58)
EXPOSE & A Little Utility Functionality
Images are Read-Only! (5:51)
Understanding Image Layers (8:20)
A First Summary (3:18)
Quiz 1: Images & Containers
Managing Images & Containers (2:01)
Stopping & Restarting Containers (4:31)
Understanding Attached & Detached Containers (7:50)
Attaching to an already-running Container
Entering Interactive Mode (10:44)
Deleting Images & Containers (6:26)
Removing Stopped Containers Automatically (3:18)
A Look Behind the Scenes: Inspecting Images (4:00)
Copying Files Into & From A Container (4:57)
Naming & Tagging Containers and Images (9:28)
Time to Practice: Images & Containers - Problem (4:00)
Time to Practice: Images & Containers - Solution (21:26)
Sharing Images - Overview (6:37)
Pushing Images to DockerHub (10:44)
Pulling & Using Shared Images (4:50)
Quiz 2: Managing Images & Containers
Module Summary (5:00)
Managing Data & Working with Volumes
Understanding Data Categories / Different Kinds of Data (7:20)
Analyzing a Real App (3:02)
Building & Understanding the Demo App (8:36)
Understanding the Problem (5:25)
Introducing Volumes (2:57)
A First, Unsuccessful Try (7:45)
Named Volumes To The Rescue! (8:35)
Removing Anonymous Volumes
Getting Started With Bind Mounts (Code Sharing) (10:42)
Combining & Merging Different Volumes (7:52)
A NodeJS-specific Adjustment: Using Nodemon in a Container (7:16)
Volumes & Bind Mounts: Summary (5:54)
Quiz 3: Volumes & Bind Mounts
A Look at Read-Only Volumes (5:40)
Managing Docker Volumes (7:39)
Using "COPY" vs Bind Mounts (3:26)
Don't COPY Everything: Using "dockerignore" Files (2:31)
Adding more to the .dockerignore File
Working with Environment Variables & ".env" Files (8:47)
Using Build Arguments (ARG) (5:09)
Networking: (Cross-)Container Communication
Case 1: Container to WWW Communication (3:49)
Case 2: Container to Local Host Machine Communication (2:13)
Case 3: Container to Container Communication (2:40)
Analyzing the Demo App (7:50)
Creating a Container & Communicating to the Web (WWW) (6:45)
Making Container to Host Communication Work (4:37)
Container to Container Communication: A Basic Solution (7:06)
Introducing Docker Networks: Elegant Container to Container Communication (10:00)
How Docker Resolves IP Addresses (2:22)
Quiz 4: Docker Container Communication & Networks
Docker Network Drivers
Building Multi-Container Applications with Docker
Our Target App & Setup (10:48)
Dockerizing the MongoDB Service (4:26)
Dockerizing the Node.js (7:30)
Moving the React SPA into a Container (8:26)
Adding Docker Networks for Efficient Cross-Container Communication (11:50)
Adding Data Persistence to MongoDB with Volumes (8:16)
Volumes, Bind Mounts & Polishing for the NodeJS Container (15:02)
Live Source Code Updates for the React Container (with Bind Mounts) (6:50)
Docker Compose: Elegant Multi-Container Orchestration
Docker-Compose: What & Why? (4:33)
Creating a Compose File (6:17)
Diving into the Compose File Configuration (11:20)
Docker Compose Up & Down (3:46)
Working with Multiple Containers (14:51)
Adding Another Container (5:55)
Building Images & Understanding Container Names (5:25)
Quiz 5: Docker Compose
Working with "Utility Containers" & Executing Commands In Containers
Module Introduction & What are "Utility Containers"? (2:39)
Utility Containers: Why would you use them? (3:02)
Different Ways of Running Commands in Containers (5:56)
Building a First Utility Container (4:51)
Utilizing ENTRYPOINT (5:27)
Using Docker Compose (6:09)
A More Complex Setup: A Laravel & PHP Dockerized Project
The Target Setup (7:13)
Adding a Nginx (Web Server) Container (8:08)
Adding a PHP Container (10:43)
Adding a MySQL Container (3:21)
Adding a Composer Utility Container (3:59)
Creating a Laravel App via the Composer Utility Container (3:36)
Launching Only Some Docker Compose Services (11:54)
Adding More Utility Containers (6:25)
Docker Compose with and without Dockerfiles (4:08)
Bind Mounts and COPY: When To Use What (14:20)
Deploying Docker Containers
From Development To Production (7:12)
Deployment Process & Providers (6:26)
Getting Started With An Example (4:02)
Bind Mounts In Production (5:05)
Introducing AWS & EC2 (2:36)
Connecting to an EC2 Instance (8:23)
Installing Docker on a Virtual Machine (1:56)
Installing Docker on Linux in General
Pushing our local Image to the Cloud (5:34)
Running & Publishing the App (on EC2) (10:20)
Managing & Updating the Container / Image (5:31)
Disadvantages of our Current Approach (4:43)
From Manual Deployment to Managed Services (5:46)
Important: AWS, Pricing and ECS
Deploying with AWS ECS: A Managed Docker Container Service (13:59)
More on AWS (4:12)
Updating Managed Containers (3:28)
Preparing a Multi-Container App (10:56)
Configuring the NodeJS Backend Container (10:31)
Deploying a Second Container & A Load Balancer (9:12)
Using a Load Balancer for a Stable Domain (5:16)
Using EFS Volumes with ECS (17:53)
Our Current Architecture (1:55)
Databases & Containers: An Important Consideration (5:16)
Moving to MongoDB Atlas (13:45)
Using MongoDB Atlas in Production (7:33)
Our Updated & Target Architecture (2:25)
Understanding a Common Problem (5:34)
Creating a "build-only" Container (4:47)
Introducing Multi-Stage Builds (7:52)
Building a Multi-Stage Image (6:09)
Deploying a Standalone Frontend App (15:53)
Development vs Production: Differences (3:51)
Understanding Multi-Stage Build Targets (2:32)
Beyond AWS (2:02)
Docker & Containers - A Summary
Images & Containers (3:36)
Key Commands (2:14)
Data, Volumes & Networking (3:13)
Docker Compose (1:11)
Local vs Remote (2:38)
Deployment (4:27)
More Problems with Manual Deployment (7:41)
Why Kubernetes? (5:12)
What Is Kubernetes Exactly? (6:54)
Kubernetes: Architecture & Core Concepts (7:37)
Kubernetes will NOT manage your Infrastructure! (3:49)
A Closer Look at the Worker Nodes (4:21)
A Closer Look at the Master Node (2:48)
Important Terms & Concepts (3:08)
Quiz 6: Kubernetes Core Concepts
Kubernetes in Action - Diving into the Core Concepts
Kubernetes does NOT manage your Infrastructure (8:41)
Kubernetes: Required Setup & Installation Steps (6:26)
macOS Setup (7:21)
Windows Setup (12:18)
Understanding Kubernetes Objects (Resources) (9:06)
The "Deployment" Object (Resource) (4:03)
A First Deployment - Using the Imperative Approach (12:53)
kubectl: Behind The Scenes (2:14)
The "Service" Object (Resource) (2:49)
Exposing a Deployment with a Service (6:10)
Restarting Containers (2:38)
Scaling in Action (2:42)
Updating Deployments (5:53)
Deployment Rollbacks & History (5:40)
The Imperative vs The Declarative Approach (4:11)
Creating a Deployment Configuration File (Declarative Approach) (6:24)
Adding Pod and Container Specs (8:48)
Working with Labels & Selectors (4:43)
Creating a Service Declaratively (9:28)
Updating & Deleting Resources (3:41)
Multiple vs Single Config Files (3:43)
More on Labels & Selectors (7:49)
Liveness Probes (4:11)
A Closer Look at the Configuration Options (5:26)
Summary (4:26)
Managing Data & Volumes with Kubernetes
Starting Project & What We Know Already (4:41)
Kubernetes & Volumes - More Than Docker Volumes (3:35)
Kubernetes Volumes: Theory & Docker Comparison (6:04)
Creating a New Deployment & Service (9:32)
Getting Started with Kubernetes Volumes (3:30)
A First Volume: The "emptyDir" Type (10:04)
A Second Volume: The "hostPath" Type (7:34)
Understanding the "CSI" Volume Type (4:07)
From Volumes to Persistent Volumes (9:08)
Defining a Persistent Volume (9:04)
Creating a Persistent Volume Claim (8:10)
Using a Claim in a Pod (6:39)
Volumes vs Persistent Volumes (6:35)
Using Environment Variables (4:48)
Environment Variables & ConfigMaps (6:08)
Kubernetes Networking
Starting Project & Our Goal (6:09)
Creating a First Deployment (6:57)
Another Look at Services (9:38)
Multiple Containers in One Pod (8:32)
Pod-internal Communication (4:29)
Creating Multiple Deployments (5:54)
Pod-to-Pod Communication with IP Addresses & Environment Variables (7:27)
Using DNS for Pod-to-Pod Communication (5:21)
Which Approach Is Best? And a Challenge! (3:09)
Challenge Solution (10:06)
Adding a Containerized Frontend (14:07)
Deploying the Frontend with Kubernetes (7:52)
Using a Reverse Proxy for the Frontend (13:57)
Kubernetes - Deployment (AWS EKS)
Deployment Options & Steps (5:42)
AWS EKS vs AWS ECS (2:49)
Preparing the Starting Project (7:40)
A Note on AWS EKS Pricing
Diving Into AWS (3:05)
Creating & Configuring the Kubernetes Cluster with EKS (15:44)
Adding Worker Nodes (8:48)
Applying Our Kubernetes Config (7:56)
Getting Started with Volumes (4:59)
Adding EFS as a Volume (with the CSI Volume Type) (4:33)
Creating a Persistent Volume for EFS (8:23)
Using the EFS Volume (8:08)
A Challenge! (3:24)
Roundup & Next Steps
You Learned A Lot! (3:23)
Related Topics You Could Explore (7:08)
Next Steps! (3:06)
Multiple vs Single Config Files