Docker & Kubernetes: The Practical Guide

Learn Docker, Docker Compose, Development Setups, Deployment and all about Kubernetes from the ground up!

Docker & Kubernetes are amongst the most in-demand topics you can learn these days.

Why?

Because they significantly simplify the development and deployment process of both simple and complex software projects. Especially in web development (though not limited to that), Docker can really take you to the next level!

With Docker, you can create and manage so-called "Containers" - basically packages of code and tools required to run that code. These containers allow you to run your programs in a predictable, environment-independent way - no matter where you need to run it.

For modern DevOps but also for local development - on your own or in a team - this is a winner feature since you will no longer have any "but it worked on my machine" discussions. It works inside of a container, hence it works everywhere!

This course will teach you both Docker & Kubernetes from the ground up by using a practice-oriented approach!

We'll explore all key concepts in detail and with practical examples and demos - from images and containers, over volumes and networking all the way up to deployment and Kubernetes Cluster: This course has it all!

In detail, this course includes the following topics:

A thorough introduction to Docker, containers and why you might want to use it
Detailed setup instructions for macOS and Windows
A deep-dive into the core concepts you need to know: Containers & images
Learn how to create custom images, use existing images and how to run containers based on such images
Get a detailed overview of the core commands you need when working with Docker
Learn how to work with data and how to persist data with volumes
Explore container networking - with the outside world and between multiple containers
Learn how to work with both single and multi-container projects
In-depth deployment instructions: Manual deployment and deployment with managed services like AWS ECS
Understand Kubernetes core concepts & architecture
Learn how to create Kubernetes resources, deployments, services and how to run your containers with Kubernetes
Dive deeply into working with data in Kubernetes projects - with different types of volumes
Kubernetes networking and DNS service discovery
Learn how to deploy your Kubernetes project (at the example of AWS EKS)
And much more!

All these topics are taught in great detail with slides and theory but also, most importantly, with many examples and demo!

You'll find tons of demo projects throughout the course - using programming languages like NodeJS, Python or PHP (with Laravel). You don't need to know these languages to follow along though, no worries!

This course is for:

Everyone who has NOT worked with Docker or Kubernetes at all
Everyone who is struggling with understanding what exactly Docker is (and why you might want to use it)
(Web) developers who are interested in advanced development topics

Course content

Section 1Getting Started

Welcome to the Course
2:32
What Is Docker?
4:42
Why Docker & Containers?
5:59
Join Our Learning Community
1:00
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
Course Outline
4:14
How To Get The Most Out Of This Course
3:24
Course Resources
1:00

Section 2Docker Images & Containers: The Core Building Blocks

Module IntroductionPremium
1:16
Images & Containers: What and Why?Premium
2:29
Using & Running External (Pre-Built) ImagesPremium
8:28
Our Goal: A NodeJS AppPremium
6:40
Building our own Image with a DockerfilePremium
11:14
Running a Container based on our own ImagePremium
7:58
EXPOSE & A Little Utility FunctionalityPremium
1:00
Images are Read-Only!Premium
5:51
Understanding Image LayersPremium
8:20
A First SummaryPremium
3:18
Quiz 1: Images & ContainersPremium
1:00
Managing Images & ContainersPremium
2:01
Stopping & Restarting ContainersPremium
4:31
Understanding Attached & Detached ContainersPremium
7:50
Attaching to an already-running ContainerPremium
1:00
Entering Interactive ModePremium
10:44
Deleting Images & ContainersPremium
6:26
Removing Stopped Containers AutomaticallyPremium
3:18
A Look Behind the Scenes: Inspecting ImagesPremium
4:00
Copying Files Into & From A ContainerPremium
4:57
Naming & Tagging Containers and ImagesPremium
9:28
Time to Practice: Images & Containers - ProblemPremium
4:00
Time to Practice: Images & Containers - SolutionPremium
21:26
Sharing Images - OverviewPremium
6:37
Pushing Images to DockerHubPremium
10:44
Pulling & Using Shared ImagesPremium
4:50
Quiz 2: Managing Images & ContainersPremium
1:00
Module SummaryPremium
5:00
Module ResourcesPremium
1:00

Section 3Managing Data & Working with Volumes

Module IntroductionPremium
1:27
Understanding Data Categories / Different Kinds of DataPremium
7:20
Analyzing a Real AppPremium
3:02
Building & Understanding the Demo AppPremium
8:36
Understanding the ProblemPremium
5:25
Introducing VolumesPremium
2:57
A First, Unsuccessful TryPremium
7:45
Named Volumes To The Rescue!Premium
8:35
Removing Anonymous VolumesPremium
1:00
Getting Started With Bind Mounts (Code Sharing)Premium
10:42
Combining & Merging Different VolumesPremium
7:52
A NodeJS-specific Adjustment: Using Nodemon in a ContainerPremium
7:16
Volumes & Bind Mounts: SummaryPremium
5:54
Quiz 3: Volumes & Bind MountsPremium
1:00
A Look at Read-Only VolumesPremium
5:40
Managing Docker VolumesPremium
7:39
Using "COPY" vs Bind MountsPremium
3:26
Don't COPY Everything: Using "dockerignore" FilesPremium
2:31
Adding more to the .dockerignore FilePremium
1:00
Working with Environment Variables & ".env" FilesPremium
8:47
Using Build Arguments (ARG)Premium
5:09
Module SummaryPremium
5:15
Module ResourcesPremium
1:00

Section 4Networking: (Cross-)Container Communication

Module IntroductionPremium
1:16
Case 1: Container to WWW CommunicationPremium
3:49
Case 2: Container to Local Host Machine CommunicationPremium
2:13
Case 3: Container to Container CommunicationPremium
2:40
Analyzing the Demo AppPremium
7:50
Creating a Container & Communicating to the Web (WWW)Premium
6:45
Making Container to Host Communication WorkPremium
4:37
Container to Container Communication: A Basic SolutionPremium
7:06
Introducing Docker Networks: Elegant Container to Container CommunicationPremium
10:00
How Docker Resolves IP AddressesPremium
2:22
Quiz 4: Docker Container Communication & NetworksPremium
1:00
Docker Network DriversPremium
2:22
Module SummaryPremium
1:26
Module ResourcesPremium
1:00

Section 5Building Multi-Container Applications with Docker

Module IntroductionPremium
2:08
Our Target App & SetupPremium
10:48
Dockerizing the MongoDB ServicePremium
4:26
Dockerizing the Node.jsPremium
7:30
Moving the React SPA into a ContainerPremium
8:26
Adding Docker Networks for Efficient Cross-Container CommunicationPremium
11:50
Adding Data Persistence to MongoDB with VolumesPremium
8:16
Volumes, Bind Mounts & Polishing for the NodeJS ContainerPremium
15:02
Live Source Code Updates for the React Container (with Bind Mounts)Premium
6:50
Module SummaryPremium
4:43
Module ResourcesPremium
1:00

Section 6Docker Compose: Elegant Multi-Container Orchestration

Module IntroductionPremium
3:08
Docker-Compose: What & Why?Premium
4:33
Creating a Compose FilePremium
6:17
Diving into the Compose File ConfigurationPremium
11:20
Docker Compose Up & DownPremium
3:46
Working with Multiple ContainersPremium
14:51
Adding Another ContainerPremium
5:55
Building Images & Understanding Container NamesPremium
5:25
Quiz 5: Docker ComposePremium
1:00
Module SummaryPremium
2:29
Module ResourcesPremium
1:00

Section 7Working with "Utility Containers" & Executing Commands In Containers

Module Introduction & What are "Utility Containers"?Premium
2:39
Utility Containers: Why would you use them?Premium
3:02
Different Ways of Running Commands in ContainersPremium
5:56
Building a First Utility ContainerPremium
4:51
Utilizing ENTRYPOINTPremium
5:27
Using Docker ComposePremium
6:09
Module SummaryPremium
1:31
Module ResourcesPremium
1:00

Section 8A More Complex Setup: A Laravel & PHP Dockerized Project

Module IntroductionPremium
2:29
The Target SetupPremium
7:13
Adding a Nginx (Web Server) ContainerPremium
8:08
Adding a PHP ContainerPremium
10:43
Adding a MySQL ContainerPremium
3:21
Adding a Composer Utility ContainerPremium
3:59
Creating a Laravel App via the Composer Utility ContainerPremium
3:36
Launching Only Some Docker Compose ServicesPremium
11:54
Adding More Utility ContainersPremium
6:25
Docker Compose with and without DockerfilesPremium
4:08
Bind Mounts and COPY: When To Use WhatPremium
14:20
Module ResourcesPremium
1:00

Section 9Deploying Docker Containers

Module IntroductionPremium
3:40
From Development To ProductionPremium
7:12
Deployment Process & ProvidersPremium
6:26
Getting Started With An ExamplePremium
4:02
Bind Mounts In ProductionPremium
5:05
Introducing AWS & EC2Premium
2:36
Connecting to an EC2 InstancePremium
8:23
Installing Docker on a Virtual MachinePremium
1:56
Installing Docker on Linux in GeneralPremium
1:00
Pushing our local Image to the CloudPremium
5:34
Running & Publishing the App (on EC2)Premium
10:20
Managing & Updating the Container / ImagePremium
5:31
Disadvantages of our Current ApproachPremium
4:43
From Manual Deployment to Managed ServicesPremium
5:46
Important: AWS, Pricing and ECSPremium
1:00
Deploying with AWS ECS: A Managed Docker Container ServicePremium
13:59
More on AWSPremium
4:12
Updating Managed ContainersPremium
3:28
Preparing a Multi-Container AppPremium
10:56
Configuring the NodeJS Backend ContainerPremium
10:31
Deploying a Second Container & A Load BalancerPremium
9:12
Using a Load Balancer for a Stable DomainPremium
5:16
Using EFS Volumes with ECSPremium
17:53
Our Current ArchitecturePremium
1:55
Databases & Containers: An Important ConsiderationPremium
5:16
Moving to MongoDB AtlasPremium
13:45
Using MongoDB Atlas in ProductionPremium
7:33
Our Updated & Target ArchitecturePremium
2:25
Understanding a Common ProblemPremium
5:34
Creating a "build-only" ContainerPremium
4:47
Introducing Multi-Stage BuildsPremium
7:52
Building a Multi-Stage ImagePremium
6:09
Deploying a Standalone Frontend AppPremium
15:53
Development vs Production: DifferencesPremium
3:51
Understanding Multi-Stage Build TargetsPremium
2:32
Beyond AWSPremium
2:02
Module SummaryPremium
6:43
Module ResourcesPremium
1:00

Section 10Docker & Containers - A Summary

Module IntroductionPremium
1:57
Images & ContainersPremium
3:36
Key CommandsPremium
2:14
Data, Volumes & NetworkingPremium
3:13
Docker ComposePremium
1:11
Local vs RemotePremium
2:38
DeploymentPremium
4:27
Module ResourcesPremium
1:00

Section 11Getting Started with Kubernetes

Module IntroductionPremium
2:16
More Problems with Manual DeploymentPremium
7:41
Why Kubernetes?Premium
5:12
What Is Kubernetes Exactly?Premium
6:54
Kubernetes: Architecture & Core ConceptsPremium
7:37
Kubernetes will NOT manage your Infrastructure!Premium
3:49
A Closer Look at the Worker NodesPremium
4:21
A Closer Look at the Master NodePremium
2:48
Important Terms & ConceptsPremium
3:08
Quiz 6: Kubernetes Core ConceptsPremium
1:00
Module ResourcesPremium
1:00

Section 12Kubernetes in Action - Diving into the Core Concepts

Module IntroductionPremium
1:25
Kubernetes does NOT manage your InfrastructurePremium
8:41
Kubernetes: Required Setup & Installation StepsPremium
6:26
macOS SetupPremium
7:21
Windows SetupPremium
12:18
Understanding Kubernetes Objects (Resources)Premium
9:06
The "Deployment" Object (Resource)Premium
4:03
A First Deployment - Using the Imperative ApproachPremium
12:53
kubectl: Behind The ScenesPremium
2:14
The "Service" Object (Resource)Premium
2:49
Exposing a Deployment with a ServicePremium
6:10
Restarting ContainersPremium
2:38
Scaling in ActionPremium
2:42
Updating DeploymentsPremium
5:53
Deployment Rollbacks & HistoryPremium
5:40
The Imperative vs The Declarative ApproachPremium
4:11
Creating a Deployment Configuration File (Declarative Approach)Premium
6:24
Adding Pod and Container SpecsPremium
8:48
Working with Labels & SelectorsPremium
4:43
Creating a Service DeclarativelyPremium
9:28
Updating & Deleting ResourcesPremium
3:41
Multiple vs Single Config FilesPremium
3:43
More on Labels & SelectorsPremium
7:49
Liveness ProbesPremium
4:11
A Closer Look at the Configuration OptionsPremium
5:26
SummaryPremium
4:26
Module ResourcesPremium
1:00

Section 13Managing Data & Volumes with Kubernetes

Module IntroductionPremium
2:22
Starting Project & What We Know AlreadyPremium
4:41
Kubernetes & Volumes - More Than Docker VolumesPremium
3:35
Kubernetes Volumes: Theory & Docker ComparisonPremium
6:04
Creating a New Deployment & ServicePremium
9:32
Getting Started with Kubernetes VolumesPremium
3:30
A First Volume: The "emptyDir" TypePremium
10:04
A Second Volume: The "hostPath" TypePremium
7:34
Understanding the "CSI" Volume TypePremium
4:07
From Volumes to Persistent VolumesPremium
9:08
Defining a Persistent VolumePremium
9:04
Creating a Persistent Volume ClaimPremium
8:10
Using a Claim in a PodPremium
6:39
Volumes vs Persistent VolumesPremium
6:35
Using Environment VariablesPremium
4:48
Environment Variables & ConfigMapsPremium
6:08
Module SummaryPremium
2:59
Module ResourcesPremium
1:00

Section 14Kubernetes Networking

Module IntroductionPremium
1:21
Starting Project & Our GoalPremium
6:09
Creating a First DeploymentPremium
6:57
Another Look at ServicesPremium
9:38
Multiple Containers in One PodPremium
8:32
Pod-internal CommunicationPremium
4:29
Creating Multiple DeploymentsPremium
5:54
Pod-to-Pod Communication with IP Addresses & Environment VariablesPremium
7:27
Using DNS for Pod-to-Pod CommunicationPremium
5:21
Which Approach Is Best? And a Challenge!Premium
3:09
Challenge SolutionPremium
10:06
Adding a Containerized FrontendPremium
14:07
Deploying the Frontend with KubernetesPremium
7:52
Using a Reverse Proxy for the FrontendPremium
13:57
Module SummaryPremium
1:52
Module ResourcesPremium
1:00

Section 15Kubernetes - Deployment (AWS EKS)

Module IntroductionPremium
1:49
Deployment Options & StepsPremium
5:42
AWS EKS vs AWS ECSPremium
2:49
Preparing the Starting ProjectPremium
7:40
A Note on AWS EKS PricingPremium
1:00
Diving Into AWSPremium
3:05
Creating & Configuring the Kubernetes Cluster with EKSPremium
15:44
Adding Worker NodesPremium
8:48
Applying Our Kubernetes ConfigPremium
7:56
Getting Started with VolumesPremium
4:59
Adding EFS as a Volume (with the CSI Volume Type)Premium
4:33
Creating a Persistent Volume for EFSPremium
8:23
Using the EFS VolumePremium
8:08
A Challenge!Premium
3:24
Challenge SolutionPremium
14:47
Module ResourcesPremium
1:00

Section 16Roundup & Next Steps

You Learned A Lot!Premium
3:23
Related Topics You Could ExplorePremium
7:08
Next Steps!Premium
3:06
Bonus!Premium
1:00

Course instructor

Maximilian Schwarzmüller

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enable me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 1,000,000 students worldwide as well as a successful YouTube channel is the best proof for that.

The most rewarding experience for me is to see how people find new, better jobs, build awesome web applications, work on amazing projects or simply enjoy their hobby with the help of my content. That's why, together with Manuel Lorenz, I founded Academind to offer the best possible learning experience and to share the pleasure of learning with our students.