Docker & Kubernetes: The Practical Guide

23h 10m 27s
English
Paid
May 22, 2024

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!

More

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 Docker & Kubernetes: The Practical Guide

Join premium to watch
Go to premium
# Title Duration
1 Welcome to the Course 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

Similar courses to Docker & Kubernetes: The Practical Guide

Docker for DevOps Engineers

Docker for DevOps Engineersamigoscode (Nelson Djalo)

Duration 4 hours 41 minutes 11 seconds
Master Microservices with Java, Spring, Docker, Kubernetes
The complete guide to running Java in Docker and Kubernetes
Mastering Kubernetes

Mastering Kubernetesamigoscode (Nelson Djalo)

Duration 8 hours 38 minutes 39 seconds
Istio Hands-On for Kubernetes

Istio Hands-On for Kubernetesudemy

Duration 12 hours 15 minutes 1 second
DevOps Deployment Automation with Terraform, AWS and Docker
React and Django: A Practical Guide with Docker

React and Django: A Practical Guide with Dockerudemy

Duration 6 hours 50 minutes 20 seconds
Cloud-Native: Microservices, Kubernetes, Service Mesh, CI/CD
Containers Under the Hood

Containers Under the Hoodudemy

Duration 11 hours 25 minutes 14 seconds