CF

Docker and Kubernetes: The Complete Guide

21h 32m 42s
English
Paid

Docker and Kubernetes: The Complete Guide is a 257-lesson 21 hours 32 minutes self-paced course by Stephen Grider, Udemy. This is the ultimate course to learn how to deploy any web application you can possibly dream up.

Course facts

Lessons
257
Duration
21 hours 32 minutes
Level
All levels
Language
English
Updated
Instructor
Stephen Grider, Udemy
Price
Premium

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 dramatically changed the flow of creating and deploying web apps.  Docker is a technology that allows applications to run in constructs called 'containers', while Kubernetes allows for many different 'containers' to run in coordination.

If you're tired of spinning your wheels learning how to deploy web applications, this is the course for you.

CI+CD Workflows? You will learn it.  AWS Deployment? Included.  Kubernetes in Production? Of course!

Docker from Scratch!

In this course you'll learn Docker from absolute fundamentals, beginning by learning the answer to basic questions such as "What is a container?" and "How does a container work?".  From the very first few lectures, we will do a deep dive on the inner workings of containers, so you get a core understanding of exactly how they are implemented.  Once you understand what a container is, you'll learn how to work with them using basic Docker CLI commands.  After that, you'll apply your new-found mastery of the Docker CLI to build your own custom images, effectively 'Dockerizing' your own personal applications. 

CI + CD Pipelines

Of course, no course on Docker would be complete without a full understanding of common Continuous Integration and Continuous Deployment patterns.  You will learn how to implement a full CI + CD workflow using Github, Travis CI, and Amazon Web Services, creating a pipeline that automatically deploys your code every time you push your latest changes to Github!

Multi-Container Deployments on AWS!

After building a deployment pipeline, you'll apply it to master both single-container and multi-container deployments on Amazon Web Services.  You will construct a multi-container application utilizing Node, React, Redis, and Postgres, and see the amazing power of containers in action (Note: all Javascript coding in this course is optional, the full source code is provided if you don't want to write JS).

Kubernetes!

Finally, you will tackle Kubernetes, a production-grade system for managing complex applications with many different running containers.  You will learn the right way to build a Kubernetes Cluster - this course doesn't have any of those annoying "don't do this in production" comments!  You will first build a Kubernetes Cluster on your local machine, then eventually move it over to a cloud provider.  You'll even learn how to set up HTTPS on Kubernetes, which is harder than it sounds!

Here's what you'll do:

  • Learn Docker from scratch, no previous experience required

  • Build your own custom images tailored to your applications

  • Master the Docker CLI to inspect and debug running containers

  • Understand how Docker works behind the scenes, and what a container is

  • Build a CI + CD pipeline from scratch with Github, Travis CI, and AWS

  • Automatically deploy your code when it is pushed to Github!

  • Build a complex multi-container application from scratch and deploy it to AWS

  • Understand the purpose and theory of Kubernetes

  • Deploy a production-ready Kubernetes Cluster to Google Cloud

Requirements:
  • Basic understanding of terminal and command line usage
  • No previous Docker or Kubernetes experience is required!
  • A credit card is required to deploy projects to AWS or Google Cloud
Who this course is for:
  • Software engineers looking to deploy their apps easily and quickly

What you'll learn:

  • Learn Docker from scratch, no previous experience required
  • Master the Docker CLI to inspect and debug running containers
  • Build a CI + CD pipeline from scratch with Github, Travis CI, and AWS
  • Understand the purpose and theory of Kubernetes by building a complex app
  • Automatically deploy your code when it is pushed to Github!

Who teaches Docker and Kubernetes: The Complete Guide?

Stephen Grider

Stephen Grider thumbnail

Stephen Grider is one of the longest-running and most prolific instructors on Udemy, with a catalog covering essentially every major JavaScript framework, plus Docker, Kubernetes, AWS, and the broader full-stack development landscape. His teaching style is patient and project-oriented — most of his courses are structured around building a substantial application from scratch rather than working through disconnected tutorial examples.

The catalog covers React, Redux, Next.js, Vue, Angular, GraphQL, Node.js, Docker / Kubernetes, AWS infrastructure, React Native and Flutter for mobile, the algorithm / data-structure interview prep track, and the modern TypeScript / Bun / Rust adjacent material that working JavaScript developers increasingly encounter. Few independent instructors have maintained Stephen's breadth this consistently for this long.

The CourseFlix listing under this source carries over 25 Stephen Grider courses spanning that range. Material is paid; Stephen Grider courses are typically sold individually on Udemy. Courses are aimed primarily at developers picking up a specific technology through working through a complete project.

Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Docker and Kubernetes: The Complete Guide?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Why Use Docker?
All Course Lessons (257)
#Lesson TitleDurationAccess
1
Why Use Docker? Demo
03:44
2
What is Docker?
02:54
3
Docker for Mac/Windows
01:58
4
Installing Docker on MacOS
04:46
5
Installing Docker for Windows Professional with HyperV
02:04
6
More Windows Professional Setup with HyperV
00:41
7
One Last Piece of Windows Professional Setup with HyperV
01:10
8
Using the Docker Client
05:04
9
But Really...What's a Container?
08:31
10
How's Docker Running on Your Computer?
02:45
11
Docker Run in Detail
01:55
12
Overriding Default Commands
05:13
13
Listing Running Containers
04:10
14
Container Lifecycle
05:17
15
Restarting Stopped Containers
03:44
16
Removing Stopped Containers
01:40
17
Retrieving Log Outputs
02:34
18
Stopping Containers
05:22
19
Multi-Command Containers
04:17
20
Executing Commands in Running Containers
02:54
21
The Purpose of the IT Flag
04:36
22
Getting a Command Prompt in a Container
04:07
23
Starting with a Shell
02:14
24
Container Isolation
03:10
25
Creating Docker Images
02:37
26
Building a Dockerfile
04:52
27
Dockerfile Teardown
02:42
28
What's a Base Image?
05:41
29
The Build Process in Detail
11:10
30
A Brief Recap
03:25
31
Rebuilds with Cache
07:03
32
Tagging an Image
04:27
33
Manual Image Generation with Docker Commit
05:01
34
Project Outline
02:36
35
Node Server Setup
05:04
36
A Few Planned Errors
05:13
37
Base Image Issues
07:51
38
A Few Missing Files
03:19
39
Copying Build Files
04:51
40
Container Port Mapping
07:27
41
Specifying a Working Directory
07:53
42
Unnecessary Rebuilds
04:17
43
Minimizing Cache Busting and Rebuilds
04:59
44
App Overview
03:58
45
App Server Starter Code
06:44
46
Assembling a Dockerfile
03:13
47
Introducing Docker Compose
05:33
48
Docker Compose Files
06:03
49
Networking with Docker Compose
05:01
50
Docker Compose Commands
04:39
51
Stopping Docker Compose Containers
02:35
52
Container Maintenance with Compose
02:54
53
Automatic Container Restarts
09:22
54
Container Status with Docker Compose
02:22
55
Development Workflow
01:29
56
Flow Specifics
06:33
57
Docker's Purpose
01:51
58
Project Generation
03:26
59
More on Project Generation
01:45
60
Necessary Commands
05:10
61
Creating the Dev Dockerfile
03:43
62
Duplicating Dependencies
01:30
63
Starting the Container
02:51
64
Docker Volumes
06:54
65
Bookmarking Volumes
04:51
66
Shorthand with Docker Compose
04:23
67
Overriding Dockerfile Selection
02:03
68
Do We Need Copy?
02:52
69
Executing Tests
03:39
70
Live Updating Tests
04:55
71
Docker Compose for Running Tests
05:46
72
Shortcomings on Testing
08:31
73
Need for Nginx
03:08
74
Multi-Step Docker Builds
06:55
75
Implementing Multi-Step Builds
07:06
76
Running Nginx
02:28
77
Services Overview
03:05
78
Github Setup
03:58
79
Travis CI Setup
04:18
80
Travis YML File Configuration
07:40
81
A Touch More Travis Setup
04:15
82
Automatic Build Creation
03:31
83
AWS Elastic Beanstalk
04:11
84
More on Elastic Beanstalk
02:26
85
Travis Config for Deployment
08:47
86
Automated Deployments
07:18
87
Exposing Ports Through the Dockerfile
03:57
88
Workflow With Github
04:00
89
Redeploy on Pull Request Merge
02:02
90
Deployment Wrapup
02:04
91
Single Container Deployment Issues
03:03
92
Application Overview
04:31
93
Application Architecture
05:12
94
Worker Process Setup
11:42
95
Express API Setup
05:20
96
Connecting to Postgres
07:37
97
More Express API Setup
12:21
98
Generating the React App
01:52
99
Fetching Data in the React App
06:32
100
Rendering Logic in the App
08:30
101
Exporting the Fib Class
00:27
102
Routing in the React App
04:37
103
Checkpoint Catchup
02:40
104
Dockerizing a React App - Again!
06:42
105
Dockerizing Generic Node Apps
03:48
106
Adding Postgres as a Service
07:06
107
Docker-compose Config
06:18
108
Environment Variables with Docker Compose
10:21
109
The Worker and Client Services
03:43
110
Nginx Path Routing
09:42
111
Routing with Nginx
11:13
112
Building a Custom Nginx Image
05:39
113
Starting Up Docker Compose
01:51
114
Troubleshooting Startup Bugs
03:23
115
Opening Websocket Connections
03:52
116
Production Multi-Container Deployments
05:40
117
Production Dockerfiles
06:06
118
Multiple Nginx Instances
05:24
119
Altering Nginx's Listen Port
04:54
120
Cleaning Up Tests
01:12
121
Github and Travis CI Setup
04:09
122
Travis Configuration Setup
08:46
123
Pushing Images to Docker Hub
07:35
124
Successful Image Building
01:50
125
Multi-Container Definition Files
04:31
126
Finding Docs on Container Definitions
03:10
127
Adding Container Definitions to DockerRun
05:46
128
More Container Definitions
05:19
129
Forming Container Links
07:48
130
Creating the EB Environment
03:31
131
Managed Data Service Providers
10:45
132
Overview of AWS VPC's and Security Groups
09:22
133
RDS Database Creation
06:32
134
ElastiCache Redis Creation
04:12
135
Creating a Custom Security Group
04:19
136
Applying Security Groups to Resources
05:00
137
Setting Environment Variables
07:56
138
IAM Keys for Deployment
05:13
139
Travis Deploy Script
03:21
140
Container Memory Allocations
04:11
141
Verifying Deployment
02:57
142
A Quick App Change
01:30
143
Making Changes
00:58
144
Cleaning Up AWS Resources
05:06
145
The Why's and What's of Kubernetes
08:07
146
Kubernetes in Development and Production
05:48
147
Minikube Setup on MacOS
05:37
148
Mapping Existing Knowledge
07:38
149
Adding Configuration Files
06:53
150
Object Types and API Versions
06:56
151
Running Containers in Pods
09:20
152
Service Config Files in Depth
13:38
153
Connecting to Running Containers
10:25
154
The Entire Deployment Flow
13:03
155
Imperative vs Declarative Deployments
13:37
156
Updating Existing Objects
06:11
157
Declarative Updates in Action
07:05
158
Limitations in Config Updates
02:56
159
Running Containers with Deployments
06:04
160
Deployment Configuration Files
03:19
161
Walking Through the Deployment Config
04:24
162
Applying a Deployment
06:23
163
Why Use Services?
05:20
164
Scaling and Changing Deployments
06:32
165
Updating Deployment Images
03:58
166
Rebuilding the Client Image
03:00
167
Triggering Deployment Updates
12:25
168
Imperatively Updating a Deployment's Image
07:25
169
Multiple Docker Installations
05:38
170
Reconfiguring Docker CLI
05:58
171
Why Mess with Docker in the Node?
05:06
172
The Path to Production
05:14
173
A Quick Checkpoint
04:37
174
Recreating the Deployment
05:31
175
NodePort vs ClusterIP Services
03:42
176
The ClusterIP Config
03:53
177
Applying Multiple Files with Kubectl
04:19
178
Express API Deployment Config
06:03
179
Cluster IP for the Express API
03:09
180
Combining Config Into Single Files
06:00
181
The Worker Deployment
04:37
182
Reapplying a Batch of Config Files
04:52
183
Creating and Applying Redis Config
07:27
184
Last Set of Boring Config!
06:15
185
The Need for Volumes with Databases
07:19
186
Kubernetes Volumes
05:18
187
Volumes vs Persistent Volumes
03:00
188
Persistent Volumes vs Persistent Volume Claims
09:23
189
Claim Config Files
02:58
190
Persistent Volume Access Modes
03:32
191
Where Does Kubernetes Allocate Persistent Volumes?
07:43
192
Designating a PVC in a Pod Template
06:10
193
Applying a PVC
02:23
194
Defining Environment Variables
04:10
195
Adding Environment Variables to Config
05:45
196
Creating an Encoded Secret
09:26
197
Passing Secrets as Environment Variables
05:54
198
Environment Variables as Strings
02:18
199
Load Balancer Services
04:15
200
A Quick Note on Ingresses
03:33
201
One Other Quick Note!
01:38
202
Behind the Scenes of Ingress
05:18
203
More Behind the Scenes of Ingress
06:39
204
Setting up Ingress Locally with Minikube
06:22
205
Creating the Ingress Configuration
07:01
206
Testing Ingress Locally
02:51
207
The Minikube Dashboard
03:29
208
The Deployment Process
05:50
209
Google Cloud vs AWS for Kubernetes
04:54
210
Creating a Git Repo
04:00
211
Linking the Github Repo to Travis
01:36
212
Creating a Google Cloud Project
02:00
213
Linking a Billing Account
02:12
214
Kubernetes Engine Init
01:48
215
Creating a Cluster with Google Cloud
04:48
216
Kubernetes Dashboard on Google Cloud
04:35
217
Travis Deployment Overview
05:05
218
Installing the Google Cloud SDK
05:45
219
Generating a Service Account
05:30
220
Running Travis CLI in a Container
09:18
221
Encrypting a Service Account File
07:55
222
More Google Cloud CLI Config
04:41
223
Running Tests with Travis
06:19
224
Custom Deployment Providers
03:50
225
Unique Deployment Images
08:34
226
Unique Tags for Built Images
07:48
227
Updating the Deployment Script
07:52
228
Configuring the GCloud CLI on Cloud Console
05:35
229
Creating a Secret on Google Cloud
02:25
230
Helm Setup
08:16
231
Kubernetes Security with RBAC
08:22
232
Assigning Tiller a Service Account
05:09
233
Ingress-Nginx with Helm
01:57
234
The Result of Ingress-Nginx
03:49
235
Finally - Deployment!
03:31
236
Did I Really Type That?
00:46
237
Verifying Deployment
05:21
238
A Workflow for Changing in Prod
04:30
239
Merging a PR for Deployment
01:02
240
That's It! What's Next?
01:38
241
HTTPS Setup Overview
05:36
242
Domain Purchase
02:18
243
Domain Name Setup
03:31
244
Cert Manager Install
01:58
245
How to Wire Up Cert Manager
05:59
246
Issuer Config File
05:08
247
Certificate Config File
05:19
248
Deploying Changes
03:16
249
Verifying the Certificate
03:55
250
Ingress Config for HTTPS
06:50
251
It Worked!
02:53
252
Awkward Local Development
03:55
253
Installing Skaffold
02:00
254
The Skaffold Config File
06:44
255
Live Sync Changes
05:03
256
Automatic Shutdown
05:08
257
Testing Live Sync with the API Server
05:30
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to Docker and Kubernetes: The Complete Guide?

More courses by Stephen Grider

Frequently asked questions

What prerequisites are needed for this course?
This course does not explicitly list prerequisites, but a basic understanding of web development and familiarity with using a command line interface would be beneficial. The course covers how to install Docker on MacOS and Windows, suggesting that users should have administrative access to their computers. It also introduces Docker and Kubernetes, so prior knowledge of these tools is not required.
What projects will be built during the course?
The course includes a project where students set up a Node server as part of the 'Node Server Setup' lesson. This project involves assembling a Dockerfile and using Docker Compose to manage containerized applications. Students will also learn about container port mapping and specifying a working directory, which are crucial for deploying web applications.
Who is the target audience for this course?
This course is aimed at individuals interested in learning how to deploy web applications using Docker and Kubernetes. It is suitable for developers who want to enhance their DevOps skills by understanding containerization and orchestration technologies. The course is ideal for those who wish to streamline their deployment processes and manage applications in a scalable manner.
What specific tools and platforms are covered in this course?
The course specifically covers the use of Docker and Kubernetes, focusing on containerization and orchestration. It includes lessons on Docker installation for both MacOS and Windows, as well as Docker Compose for managing multi-container applications. These tools are essential for deploying and managing scalable web applications in a DevOps environment.
What topics are not covered in this course?
The course does not cover advanced Kubernetes configurations or cloud-specific deployment strategies. While it provides a comprehensive overview of Docker and Kubernetes fundamentals, learners looking for deep dives into cloud platform integrations or Kubernetes network policies may need additional resources. The lessons focus on local setups and basic orchestration concepts.
How much time will I need to complete the course?
The total runtime of the course is approximately 21 hours and 33 minutes, spread over 257 lessons. Depending on your pace and time spent on exercises, it might take a few weeks to fully complete. Allocating regular study sessions and time for hands-on practice with the provided exercises will help reinforce learning and ensure a thorough understanding of the material.
How can the skills learned in this course benefit my career?
Learning Docker and Kubernetes can significantly enhance your career in software development and IT operations. These technologies are increasingly important for deploying and managing applications at scale. Mastery of containerization and orchestration can open opportunities in DevOps roles, improve deployment workflows, and streamline application management in cloud environments. These skills are also transferable to other courses and technologies focused on cloud and infrastructure automation.