Docker & Kubernetes: The Practical Guide

23h 10m 27s
English
Paid

Course description

Docker & Kubernetes are amongst the most in-demand technologies and 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!

Read more about the course

With Docker, you 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 with all the required theory and tons of examples and demos!

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 Docker

  • 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!

Watch Online

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 229 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing

Watch Online Docker & Kubernetes: The Practical Guide

0:00
/
#1: Welcome to the Course

All Course Lessons (229)

#Lesson TitleDurationAccess
1
Welcome to the Course Demo
02:33
2
What Is Docker?
04:43
3
Why Docker & Containers?
06:00
4
Virtual Machines vs Docker Containers
08:56
5
Docker Setup - Overview
04:32
6
Docker Setup - macOS
03:35
7
Docker Setup - Windows
09:45
8
Docker Setup - Docker Toolbox for Older Systems
06:52
9
An Overview of the Docker Tools
03:06
10
Installing & Configuring an IDE
02:08
11
Getting Our Hands Dirty!
09:24
12
Course Outline
04:15
13
How To Get The Most Out Of This Course
03:25
14
Module Introduction
01:17
15
Images & Containers: What and Why?
02:30
16
Using & Running External (Pre-Built) Images
08:29
17
Our Goal: A NodeJS App
06:41
18
Building our own Image with a Dockerfile
11:15
19
Running a Container based on our own Image
07:59
20
Images are Read-Only!
05:52
21
Understanding Image Layers
08:21
22
A First Summary
03:19
23
Managing Images & Containers
02:02
24
Stopping & Restarting Containers
04:32
25
Understanding Attached & Detached Containers
07:51
26
Entering Interactive Mode
10:45
27
Deleting Images & Containers
06:27
28
Removing Stopped Containers Automatically
03:19
29
A Look Behind the Scenes: Inspecting Images
04:01
30
Copying Files Into & From A Container
04:59
31
Naming & Tagging Containers and Images
09:29
32
Sharing Images - Overview
06:38
33
Pushing Images to DockerHub
10:45
34
Pulling & Using Shared Images
04:51
35
Module Summary
05:01
36
Module Introduction
01:28
37
Understanding Data Categories / Different Kinds of Data
07:21
38
Analyzing a Real App
03:03
39
Building & Understanding the Demo App
08:37
40
Understanding the Problem
05:26
41
Introducing Volumes
02:58
42
A First, Unsuccessful Try
07:46
43
Named Volumes To The Rescue!
08:37
44
Getting Started With Bind Mounts (Code Sharing)
10:43
45
Combining & Merging Different Volumes
07:53
46
A NodeJS-specific Adjustment: Using Nodemon in a Container
07:17
47
Volumes & Bind Mounts: Summary
05:55
48
A Look at Read-Only Volumes
05:41
49
Managing Docker Volumes
07:40
50
Using "COPY" vs Bind Mounts
03:28
51
Don't COPY Everything: Using "dockerignore" Files
02:32
52
Working with Environment Variables & ".env" Files
08:48
53
Using Build Arguments (ARG)
05:10
54
Module Summary
05:16
55
Module Introduction
01:17
56
Case 1: Container to WWW Communication
03:51
57
Case 2: Container to Local Host Machine Communication
02:15
58
Case 3: Container to Container Communication
02:42
59
Analyzing the Demo App
07:51
60
Creating a Container & Communicating to the Web (WWW)
06:46
61
Making Container to Host Communication Work
04:38
62
Container to Container Communication: A Basic Solution
07:07
63
Introducing Docker Networks: Elegant Container to Container Communication
10:01
64
How Docker Resolves IP Addresses
02:23
65
Module Summary
01:27
66
Module Introduction
02:09
67
Our Target App & Setup
10:49
68
Dockerizing the MongoDB Service
04:27
69
Dockerizing the Node App
07:31
70
Moving the React SPA into a Container
08:27
71
Adding Docker Networks for Efficient Cross-Container Communication
11:51
72
Adding Data Persistence to MongoDB with Volumes
08:17
73
Volumes, Bind Mounts & Polishing for the NodeJS Container
15:03
74
Live Source Code Updates for the React Container (with Bind Mounts)
06:51
75
Module Summary
04:44
76
Module Introduction
03:09
77
Docker-Compose: What & Why?
04:35
78
Creating a Compose File
06:18
79
Diving into the Compose File Configuration
11:21
80
Docker Compose Up & Down
03:47
81
Working with Multiple Containers
14:52
82
Adding Another Container
05:56
83
Building Images & Understanding Container Names
05:26
84
Module Summary
02:30
85
Module Introduction & What are "Utility Containers"?
02:40
86
Utility Containers: Why would you use them?
03:03
87
Different Ways of Running Commands in Containers
05:57
88
Building a First Utility Container
04:52
89
Utilizing ENTRYPOINT
05:28
90
Using Docker Compose
06:10
91
Module Summary
01:32
92
Module Introduction
02:30
93
The Target Setup
07:14
94
Adding a Nginx (Web Server) Container
08:09
95
Adding a PHP Container
10:45
96
Adding a MySQL Container
03:22
97
Adding a Composer Utility Container
04:01
98
Creating a Laravel App via the Composer Utility Container
03:37
99
Launching Only Some Docker Compose Services
11:55
100
Adding More Utility Containers
06:26
101
Docker Compose with and without Dockerfiles
04:09
102
Bind Mounts and COPY: When To Use What
14:21
103
Module Introduction
03:41
104
From Development To Production
07:13
105
Deployment Process & Providers
06:27
106
Getting Started With An Example
04:03
107
Bind Mounts In Production
05:06
108
Introducing AWS & EC2
02:37
109
Connecting to an EC2 Instance
08:24
110
Installing Docker on a Virtual Machine
01:57
111
Pushing our local Image to the Cloud
05:35
112
Running & Publishing the App (on EC2)
10:21
113
Managing & Updating the Container / Image
05:32
114
Disadvantages of our Current Approach
04:44
115
From Manual Deployment to Managed Services
05:47
116
Deploying with AWS ECS: A Managed Docker Container Service
14:00
117
More on AWS
04:13
118
Updating Managed Containers
03:29
119
Preparing a Multi-Container App
10:57
120
Configuring the NodeJS Backend Container
10:32
121
Deploying a Second Container & A Load Balancer
09:13
122
Using a Load Balancer for a Stable Domain
05:17
123
Using EFS Volumes with ECS
17:54
124
Our Current Architecture
01:56
125
Databases & Containers: An Important Consideration
05:17
126
Moving to MongoDB Atlas
13:46
127
Using MongoDB Atlas in Production
07:34
128
Our Updated & Target Architecture
02:26
129
Understanding a Common Problem
05:36
130
Creating a "build-only" Container
04:48
131
Introducing Multi-Stage Builds
07:53
132
Building a Multi-Stage Image
06:10
133
Deploying a Standalone Frontend App
15:54
134
Development vs Production: Differences
03:52
135
Understanding Multi-Stage Build Targets
02:33
136
Beyond AWS
02:04
137
Module Summary
06:44
138
Module Introduction
00:58
139
Images & Containers
03:37
140
Key Commands
02:15
141
Data, Volumes & Networking
03:14
142
Docker Compose
01:12
143
Local vs Remote
02:39
144
Deployment
04:29
145
Module Introduction
02:17
146
More Problems with Manual Deployment
07:42
147
Why Kubernetes?
05:14
148
What Is Kubernetes Exactly?
06:55
149
Kubernetes: Architecture & Core Concepts
07:38
150
Kubernetes will NOT manage your Infrastructure!
03:50
151
A Closer Look at the Worker Nodes
04:22
152
A Closer Look at the Master Node
02:49
153
Important Terms & Concepts
03:09
154
Module Introduction
01:26
155
Kubernetes does NOT manage your Infrastructure
08:42
156
Kubernetes: Required Setup & Installation Steps
06:27
157
macOS Setup
07:22
158
Windows Setup
12:19
159
Understanding Kubernetes Objects (Resources)
09:07
160
The "Deployment" Object (Resource)
04:04
161
A First Deployment - Using the Imperative Approach
12:54
162
kubectl: Behind The Scenes
02:15
163
The "Service" Object (Resource)
02:50
164
Exposing a Deployment with a Service
06:11
165
Restarting Containers
02:39
166
Scaling in Action
02:43
167
Updating Deployments
05:54
168
Deployment Rollbacks & History
05:41
169
The Imperative vs The Declarative Approach
04:13
170
Creating a Deployment Configuration File (Declarative Approach)
06:25
171
Adding Pod and Container Specs
08:49
172
Working with Labels & Selectors
04:44
173
Creating a Service Declaratively
09:30
174
Updating & Deleting Resources
03:42
175
Multiple vs Single Config Files
03:44
176
More on Labels & Selectors
07:50
177
Liveness Probes
04:12
178
A Closer Look at the Configuration Options
05:27
179
Summary
04:27
180
Module Introduction
02:23
181
Starting Project & What We Know Already
04:42
182
Kubernetes & Volumes - More Than Docker Volumes
03:36
183
Kubernetes Volumes: Theory & Docker Comparison
06:05
184
Creating a New Deployment & Service
09:34
185
Getting Started with Kubernetes Volumes
03:31
186
A First Volume: The "emptyDir" Type
10:05
187
A Second Volume: The "hostPath" Type
07:35
188
Understanding the "CSI" Volume Type
04:08
189
From Volumes to Persistent Volumes
09:09
190
Defining a Persistent Volume
09:05
191
Creating a Persistent Volume Claim
08:11
192
Using a Claim in a Pod
06:40
193
Volumes vs Persistent Volumes
06:36
194
Using Environment Variables
04:49
195
Environment Variables & ConfigMaps
06:10
196
Module Summary
03:00
197
Module Introduction
01:23
198
Starting Project & Our Goal
06:10
199
Creating a First Deployment
06:58
200
Another Look at Services
09:39
201
Multiple Containers in One Pod
08:33
202
Pod-internal Communication
04:30
203
Creating Multiple Deployments
05:55
204
Pod-to-Pod Communication with IP Addresses & Environment Variables
07:28
205
Using DNS for Pod-to-Pod Communication
05:22
206
Which Approach Is Best? And a Challenge!
03:10
207
Challenge Solution
10:07
208
Adding a Containerized Frontend
14:08
209
Deploying the Frontend with Kubernetes
07:53
210
Using a Reverse Proxy for the Frontend
13:58
211
Module Summary
01:53
212
Module Introduction
01:51
213
Deployment Options & Steps
05:43
214
AWS EKS vs AWS ECS
02:50
215
Preparing the Starting Project
07:41
216
Diving Into AWS
03:06
217
Creating & Configuring the Kubernetes Cluster with EKS
15:45
218
Adding Worker Nodes
08:49
219
Applying Our Kubernetes Config
07:57
220
Getting Started with Volumes
05:00
221
Adding EFS as a Volume (with the CSI Volume Type)
04:35
222
Creating a Persistent Volume for EFS
08:24
223
Using the EFS Volume
08:10
224
A Challenge!
03:26
225
Challenge Solution
14:48
226
You Learned A Lot!
03:24
227
Related Topics You Could Explore
07:09
228
Next Steps!
03:07
229
Course Roundup
00:56

Unlock unlimited learning

Get instant access to all 228 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Istio Hands-On for Kubernetes

Istio Hands-On for Kubernetes

Sources: udemy
Istio is one of the most talked-about frameworks in recent years! If you've worked with Kubernetes before, then you'll want to learn Istio! With this hands-on, practical course,...
12 hours 15 minutes 1 second
Docker and Kubernetes: The Complete Guide

Docker and Kubernetes: The Complete Guide

Sources: udemy, Stephen Grider
This is the ultimate course to learn how to deploy any web application you can possibly dream up. Docker and Kubernetes are the newest tech in the Dev Ops world, and have drama...
21 hours 32 minutes 42 seconds
React and Django: A Practical Guide with Docker

React and Django: A Practical Guide with Docker

Sources: udemy
Learn how to create an Admin App using React and Django Rest Framework. Django 3.1, React Typescript, Redux, Docker, Authentication and Authorisation, Upload Im
6 hours 50 minutes 20 seconds
Mastering Kubernetes

Mastering Kubernetes

Sources: Amigoscode (Nelson Djalo)
Kubernetes is the world's most popular open-source container orchestration engine. It offers the ability to schedule and manage containers.
8 hours 38 minutes 39 seconds