Top 8 Recommended Kubernetes Self-Study Materials! [December 2023]

*** Updated for latest CKA (2022) 1.27 version of Exam ***

Kubernetes is one of the highest trending technology in Cloud Computing as of today. Kubernetes had the fastest growth in job searches, over 173% from a year before, as reported recently by a survey conducted by Indeed.

Learn, practice, and get certified on Kubernetes with hands-on labs right in your browser.

"I have compared this to other courses at Udemy and Linux Academy. All have the strengths and gaps; so far this is a winner!" -  Thomas Trauss, Student.

Learning Kubernetes is essential for any DevOps professional. DevOps engineers are always in demand. Currently, the average Silicon Valley salary for a DevOps engineer is 20% higher than what a software engineer makes. DevOps engineers make an average of $140,000 to $200,000 annually. And one of the most in-demand skills is Kubernetes Administration.

Kubernetes is an open-source system for automating containerized application deployment, scaling, and management. It was originally designed by Google and is now maintained by the Cloud Native Computing Foundation.

                                                                                                    Simplify Complex Technology

Kubernetes is at the cutting edge of application deployment. To elevate your DevOps career, learn how to deploy applications on Kubernetes effectively.

This course helps you gain the knowledge required to design and deploy cloud-native applications on a Kubernetes cluster.  A series of well-designed lectures with animation and illustrations help you understand complex concepts easily.

                                                                                                     Practice! Practice! Practice!

Lectures alone won’t help you clear the certification. The Kubernetes Certification is a practical hands-on exam. You need hands-on experience, you need to get fast, and you need practice. That is what our integrated hands-on lab experience gives you. Our coding quizzes can be accessed right in your browser without having to set up any lab environment yourself. We validate your work and give you feedback instantly. Preview a few lab exercises for Free!!

After you have completed the lectures and coding exercises, you will have the opportunity to complete a series of assignments that put your new skills to the test. You will be given the challenge to solve using the Kubernetes skills you have learned.

This will give you real-world experience and the chance to work with other students in the community. You will develop a Kubernetes deployment and get feedback for your work.

                                                                                                      Join Our Community!

Once you enroll in the course, you will get access to our community of teachers and learners on Slack, where we discuss important topics, tips, and tricks to pass the exam. This is a great place for you to clear your doubts and get answers to your questions instantly.

This course is the best way to get Certified in Kubernetes for an Absolute Beginner.

Don’t waste any more time wondering what course is best for you. You’ve already found it. Get started right away!

"Straight to the point covers the necessary to take the exam with some additional practice. Very good course and a very good teacher. Top-notch! Update: I passed the exam using this course!" - Christopher Williamson, Student, Udemy

Legal Notice:

Kubernetes and the Kubernetes logo are trademarks or registered trademarks of The Linux Foundation. in the United States and/or other countries. The Linux Foundation and other parties may also have trademark rights in other terms used herein. This course is not certified, accredited, affiliated with, nor endorsed by Kubernetes or The Linux Foundation.

Course Update History

• June 15, 2023 – Lab environment upgrade to 1.27v

• Feb 2, 2023 – Lab environment upgrade to 1.26v

• Oct 10, 2022 – Lab environment upgrade to 1.24v

• Sept 2, 2022 - New lab on etcd added

• May 15, 2022 - Mock Exam solution videos updated

• May 1, 2022 – Lab environment upgrade to 1.23v

• Oct 20, 2021 – Lab environment upgrade to 1.22v

• May 10, 2021 – Lab environment upgrade to 1.20v

• Aug 24, 2020 – New updates
  Lab environment upgrade to v1.19
  New lectures Storage Section, Troubleshooting Section, kubectl apply, Solution videos, and labs were added.
  Updated Kubernetes Imperative Commands Lab.

• Jun 16, 2020 – Lab environment upgrade to v1.18

• Dec 3, 2019 – New labs added

• Jul 5, 2019 – New Mock Exam to the Kubernetes Certification Courses added

• Jun 7, 2019 – New lectures on Practice Imperative Commands, Multi Container PODs, and Init Containers, along with labs, were added

• May 21, 2019 – Lab Updates and fixes

1. Introduction
2. Course Introduction
3. Certification
4. Certification Details
5. Course Release Notes
6. The Kubernetes Trilogy
7. Join our Slack Channel for support and interaction
8. A note on the Course Curriculum
9. Reference Notes for lectures and labs
10. Core Concepts
11. Core Concepts Section Introduction
12. Download Presentation Deck for this section
13. Cluster Architecture
14. Docker-vs-ContainerD
15. ETCD For Beginners
16. ETCD in Kubernetes
17. ETCD - Commands (Optional)
18. Kube-API Server
19. Kube Controller Manager
20. Kube Scheduler
21. Kubelet
22. Kube Proxy
23. Recap - Pods
24. Pods with YAML
25. Demo - Pods with YAML
26. Practice Test Introduction
27. Demo: Accessing Labs
28. Accessing the Labs
29. Practice Test - Pods
30. Practice Test - Solution (Optional)
31. Recap - ReplicaSets
32. Practice Test - ReplicaSets
33. Practice Test - ReplicaSets - Solution (Optional)
34. Deployments
35. Certification Tip!
36. Practice Test - Deployments
37. Solution - Deployments (optional)
38. Services
39. Services Cluster IP
40. Services - Loadbalancer
41. Practice Test - Services
42. Solution - Services (optional)
43. Namespaces
44. Practice Test - Namespaces
45. Solution - Namespaces (optional)
46. Imperative vs Declarative
47. Certification Tips - Imperative Commands with Kubectl
48. Practice Test - Imperative Commands
49. Solution - Imperative Commands (optional)
50. Kubectl Apply Command
51. Here's some inspiration to keep going
52. A Quick Reminder
53. Scheduling
54. Scheduling Section Introduction
55. Download Presentation Deck for this section
56. Manual Scheduling
57. Practice Test - Manual Scheduling
58. Solution - Manual Scheduling (optional)
59. Labels and Selectors
60. Practice Test - Labels and Selectors
61. Solution : Labels and Selectors : (Optional)
62. Taints and Tolerations
63. Practice Test - Taints and Tolerations
64. Solution - Taints and Tolerations (Optional)
65. Node Selectors
66. Node Affinity
67. Practice Test - Node Affinity
68. Solution - Node Affinity (Optional)
69. Taints and Tolerations vs Node Affinity
70. Resource Requirements and Limits
71. A quick note on editing Pods and Deployments
72. Practice Test - Resource Requirements and Limits
73. Solution: Resource Limits : (Optional)
74. DaemonSets
75. Practice Test - DaemonSets
76. Solution - DaemonSets (optional)
77. Static Pods
78. Practice Test - Static Pods
79. Solution - Static Pods (Optional)
80. Multiple Schedulers
81. Practice Test - Multiple Schedulers
82. Solution - Practice Test - Multiple Schedulers : (Optional)
83. Configuring Scheduler Profiles
84. References
85. Logging & Monitoring
86. Logging and Monitoring Section Introduction
87. Download Presentation Deck
88. Monitor Cluster Components
89. Practice Test - Monitoring
90. Solution: Monitor Cluster Components : (Optional)
91. Managing Application Logs
92. Practice Test - Monitor Application Logs
93. Solution: Logging : (Optional)
94. Application Lifecycle Management
95. Application Lifecycle Management - Section Introduction
96. Download Slide Deck
97. Rolling Updates and Rollbacks
98. Practice Test - Rolling Updates and Rollbacks
99. Solution: Rolling update : (Optional)
100. Configure Applications
101. Commands
102. Commands and Arguments
103. Practice Test - Commands and Arguments
104. Solution - Commands and Arguments (Optional)
105. Configure Environment Variables in Applications
106. Configuring ConfigMaps in Applications
107. Practice Test: Environment Variables
108. Solution - Environment Variables (Optional)
109. Configure Secrets in Applications
110. A note about Secrets!
111. Practice Test - Secrets
112. Solution - Secrets (Optional)
113. Demo: Encrypting Secret Data at Rest
114. Scale Applications
115. Multi Container Pods
116. Practice Test - Multi Container Pods
117. Solution - Multi-Container Pods (Optional)
118. Multi-container Pods Design Patterns
119. InitContainers
120. Practice Test - Init Containers
121. Solution - Init Containers (Optional)
122. Self Healing Applications
123. If you like it, Share it!
124. Cluster Maintenance
125. Cluster Maintenance - Section Introduction
126. Download Presentation Deck
127. OS Upgrades
128. Practice Test - OS Upgrades
129. Solution - OS Upgrades (optional)
130. Kubernetes Software Versions
131. References
132. Cluster Upgrade Process
133. Demo - Cluster upgrade
134. Practice Test - Cluster Upgrade
135. Solution: Cluster Upgrade
136. Backup and Restore Methods
137. Working with ETCDCTL
138. Practice Test - Backup and Restore Methods
139. Solution - Backup and Restore
140. Practice Test Backup and Restore Methods 2
141. Solution: Backup and Restore 2
142. Certification Exam Tip!
143. References
144. Security
145. Security - Section Introduction
146. Download Presentation Deck
147. Kubernetes Security Primitives
148. Authentication
149. Article on Setting up Basic Authentication
150. A note on Service Accounts
151. TLS Introduction
152. TLS Basics
153. TLS in Kubernetes
154. TLS in Kubernetes - Certificate Creation
155. View Certificate Details
156. Resource: Download Kubernetes Certificate Health Check Spreadsheet
157. Practice Test - View Certificates
158. Solution - View Certification Details
159. Certificates API
160. Practice Test - Certificates API
161. Solution Certificates API
162. KubeConfig
163. Practice Test - KubeConfig
164. Solution KubeConfig
165. Persistent Key/Value Store
166. API Groups
167. Authorization
168. Role Based Access Controls
169. Practice Test - RBAC
170. Solution Role Based Access Controls
171. Cluster Roles and Role Bindings
172. Practice Test - Cluster Roles and Role Bindings
173. Solution Cluster Roles
174. Service Accounts
175. Practice Test Service Accounts
176. Solution Service Accounts
177. Image Security
178. Practice Test - Image Security
179. Solution Image Security
180. Pre-requisite - Security in Docker
181. Security Contexts
182. Practice Test - Security Contexts
183. Solution Security Contexts
184. Network Policy
185. Developing network policies
186. Practice Test - Network Policy
187. Kubectx and Kubens – Command line Utilities
188. Solution - Network Policies (optional)
189. Storage
190. Storage - Section Introduction
191. Introduction to Docker Storage
192. Storage in Docker
193. Volume Driver Plugins in Docker
194. Container Storage Interface (CSI)
195. Download Slide Deck
196. Volumes
197. Persistent Volumes
198. Persistent Volume Claims
199. Using PVCs in Pods
200. Practice Test - Persistent Volumes and Persistent Volume Claims

“This is by far the best Kubernetes course on Udemy”—Student Testimonial.   

Learning Kubernetes is essential for any DevOps professional. DevOps engineers are always in demand. The average Silicon Valley salary for a DevOps engineer is 20% higher than a software engineers'.    

DevOps engineers make an average of $140,000 to $200,000 annually. And one of the most in-demand skills is Kubernetes Deployment.

Kubernetes is an open-source system for automating containerized application deployment, scaling, and management. It was originally designed by Google and is now maintained by the Cloud Native Computing Foundation.

Kubernetes is at the cutting edge of application deployment. The best way to kick-start your DevOps career is by learning how to deploy Kubernetes effectively.   

This course is for absolute Kubernetes beginners. With zero knowledge about Kubernetes, once you take this course and complete all of the hands-on coding exercises, you will be ready to deploy your own applications on a Kubernetes platform.   

"Excellent course. If you are new to Kubernetes and have never used it before, as was my case, I highly recommend this." - Student Testimonial.

As a beginner, you will start your journey and go through 10 simple, step-by-step lectures. Each lecture and demo is designed to give you the time to grasp all the concepts fully. The most important part of the course is the series of hands-on coding exercises that accompany each major concept.   

But lectures alone won’t give you the skills you need to make it as a DevOps engineer. In this course, you will learn by doing. Each exercise will help you make sure you have truly mastered the concepts and will help you have the confidence to apply your Kubernetes knowledge in real-world situations.

"Perfect Kubernetes 101. Enough to understand the topic and know how to proceed further." - Student Testimonial

You will be developing your services using Kubernetes configuration files for different use cases in your browser. The coding exercises will validate your commands to ensure you have written them correctly.   

After you have completed the lectures and coding exercises, you will have the opportunity to complete a series of assignments that put your new skills to the test. You will be given the challenge to solve using the Kubernetes skills you have learned.    

This will give you real-world experience and the chance to work with other students in the community. You will develop a Kubernetes deployment and get feedback for your work.   

This course is the best way to learn the Kubernetes skills you will need to succeed in your DevOps career.   

Don’t waste any more time wondering what course is best for you. You’ve already found it. Get started right now getting the Kubernetes skills you need to be successful as a DevOps engineer.

"The Best Course for the Kubernetes For Beginners, the perfect search ends here." - Student Testimonial.

Legal Notice:

Kubernetes and the Kubernetes logo are trademarks or registered trademarks of The Linux Foundation. in the United States and/or other countries. The Linux Foundation and other parties may also have trademark rights in other terms used herein. This course is not certified, accredited, affiliated with, nor endorsed by Kubernetes or The Linux Foundation.

Course Update History

• June 15, 2023 – Lab environment upgrade to 1.27v

• Feb 2, 2023 – Lab environment upgrade to 1.26v

• Oct 10, 2022 – Lab environment upgrade to 1.24v

• May 10, 2022 – Lab solutions added

• May 1, 2022 – Lab environment upgrade to 1.23v

• Oct 20, 2021 – Lab environment upgrade to 1.22v

• May 10, 2021 – Lab environment upgrade to 1.20v

• Aug 24, 2020 – Lab environment upgrade to 1.19v

• Jun 16, 2020 – Lab environment upgrade to 1.18v

1. Introduction
2. Introduction
3. The Kubernetes Course Series
4. Demo - How to Access the Labs?
5. Accessing the Labs
6. Course Resources
7. Course release notes
8. Join our Community
9. Kubernetes Overview
10. Containers Overview
11. Container Orchestration
12. Kubernetes Architecture
13. Architecture
14. Student Preferences
15. A Quick Reminder
16. Kubernetes Concepts
17. Pods
18. Demo - Pods
19. Reference - Pods
20. Pods
21. YAML Introduction
22. Introduction to YAML
23. Introduction to Coding Exercises
24. Coding Exercises - Answer Keys
25. YAML - 1
26. YAML - 2
27. YAML - 3
28. YAML - 4
29. YAML - 5
30. YAML - 6
31. Kubernetes Concepts - Pods, ReplicaSets, Deployments
32. Pods with YAML
33. Demo - Pods with YAML
34. Tips & Tricks - Developing Kubernetes Manifest files with Visual Studio Code
35. Pods - 1
36. Pods - 2
37. Pods - 3
38. Pods - 4
39. Pods - 5
40. Pods - 6
41. Pods - 7
42. Pods - 8
43. Pods - 9
44. Hands-On Labs - Familiarise with the lab environment
45. Hands-On Labs
46. Solution : Pods with YAML Lab
47. Replication Controllers and ReplicaSets
48. Demo - ReplicaSets
49. ReplicaSet - 1
50. ReplicaSet - 2
51. ReplicaSet - 3
52. ReplicaSet - 4
53. ReplicaSet - 5
54. ReplicaSet - 6
55. ReplicaSet - 7
56. Hands-On Labs
57. Solution - ReplicaSets
58. Deployments
59. Demo - Deployments
60. Deployment - 1
61. Deployment - 2
62. Deployment - 3
63. Deployment - 4
64. Deployment - 5
65. Deployment - 6
66. Deployment - 7
67. Hands-On Labs
68. Solution - Deployments
69. Deployments - Update and Rollback
70. Demo - Deployments - Update and Rollback
71. Lab: Practice Test Rolling Updates and Rollbacks
72. Solution - Rolling Updates and Rollbacks
73. Networking in Kubernetes
74. Basics of Networking in Kubernetes
75. Services
76. Services - NodePort
77. Demo - Services
78. Services - ClusterIP
79. Services - Load Balancer
80. Services - 1
81. Services - 2
82. Services - 3
83. Services - 4
84. Services - 5
85. Services - 6
86. Services - 7
87. Services - 8
88. Hands-On Labs
89. Solution - Services
90. Microservices Architecture
91. Microservices Application
92. Microservices Application on Kubernetes
93. Demo - Deploying Microservices Application on Kubernetes
94. Demo - Deploying Microservices Application on Kubernetes with Deployments
95. Article: Demo lecture manifest files
96. Kubernetes on Cloud
97. Kubernetes on Cloud - Introduction
98. Kubernetes on GCP (GKE)
99. Reference - Google Cloud Platform
100. Kubernetes on AWS (EKS)
101. Kubernetes on Azure (AKS)
102. Conclusion
103. Conclusion
104. Appendix - Setup Multi Node cluster using Kubeadm
105. Reference
106. Kubernetes Setup - Kubeadm
107. Demo - Setup Lab - VirtualBox
108. Demo - Provision cluster using Kubeadm
109. Kubernetes Setup - Introduction and Minikube
110. Setup Kubernetes
111. Reference
112. Bonus Lecture: Kubernetes Series of Courses
113. References
114. Demo - Minikube

Join this bestselling Docker & Kubernetes course and learn two of the most important development technologies from the ground up, in great detail!

-

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!

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 (Development Operations) 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!

1. Getting Started
2. Welcome to the Course
3. What Is Docker?
4. Why Docker & Containers?
5. Join Our Learning Community
6. Virtual Machines vs Docker Containers
7. Docker Setup - Overview
8. Docker Setup - macOS
9. Docker Setup - Windows
10. Docker Setup - Docker Toolbox for Older Systems
11. Docker Playground
12. An Overview of the Docker Tools
13. Installing & Configuring an IDE
14. Getting Our Hands Dirty!
15. Course Outline
16. How To Get The Most Out Of This Course
17. Course Resources
18. Docker Images & Containers: The Core Building Blocks
19. Module Introduction
20. Images & Containers: What and Why?
21. Using & Running External (Pre-Built) Images
22. Our Goal: A NodeJS App
23. Building our own Image with a Dockerfile
24. Running a Container based on our own Image
25. EXPOSE & A Little Utility Functionality
26. Images are Read-Only!
27. Understanding Image Layers
28. A First Summary
29. Images & Containers
30. Managing Images & Containers
31. Stopping & Restarting Containers
32. Understanding Attached & Detached Containers
33. Attaching to an already-running Container
34. Entering Interactive Mode
35. Deleting Images & Containers
36. Removing Stopped Containers Automatically
37. A Look Behind the Scenes: Inspecting Images
38. Copying Files Into & From A Container
39. Naming & Tagging Containers and Images
40. Time to Practice: Images & Containers
41. Sharing Images - Overview
42. Pushing Images to DockerHub
43. Pulling & Using Shared Images
44. Managing Images & Containers
45. Module Summary
46. Module Resources
47. Managing Data & Working with Volumes
48. Module Introduction
49. Understanding Data Categories / Different Kinds of Data
50. Analyzing a Real App
51. Building & Understanding the Demo App
52. Understanding the Problem
53. Introducing Volumes
54. A First, Unsuccessful Try
55. Named Volumes To The Rescue!
56. Removing Anonymous Volumes
57. Getting Started With Bind Mounts (Code Sharing)
58. Bind Mounts - Shortcuts
59. Combining & Merging Different Volumes
60. A NodeJS-specific Adjustment: Using Nodemon in a Container
61. Volumes & Bind Mounts: Summary
62. Volumes & Bind Mounts
63. A Look at Read-Only Volumes
64. Managing Docker Volumes
65. Using "COPY" vs Bind Mounts
66. Don't COPY Everything: Using "dockerignore" Files
67. Adding more to the .dockerignore File
68. Working with Environment Variables & ".env" Files
69. Environment Variables & Security
70. Using Build Arguments (ARG)
71. Module Summary
72. Module Resources
73. Networking: (Cross-)Container Communication
74. Module Introduction
75. Case 1: Container to WWW Communication
76. Case 2: Container to Local Host Machine Communication
77. Case 3: Container to Container Communication
78. Analyzing the Demo App
79. Creating a Container & Communicating to the Web (WWW)
80. Making Container to Host Communication Work
81. Container to Container Communication: A Basic Solution
82. Introducing Docker Networks: Elegant Container to Container Communication
83. How Docker Resolves IP Addresses
84. Docker Container Communication & Networks
85. Docker Network Drivers
86. Module Summary
87. Module Resources
88. Building Multi-Container Applications with Docker
89. Module Introduction
90. Our Target App & Setup
91. Dockerizing the MongoDB Service
92. Dockerizing the Node App
93. Moving the React SPA into a Container
94. Adding Docker Networks for Efficient Cross-Container Communication
95. Fixing MongoDB Authentication Errors (relevant for next lecture)
96. Adding Data Persistence to MongoDB with Volumes
97. Volumes, Bind Mounts & Polishing for the NodeJS Container
98. Live Source Code Updates for the React Container (with Bind Mounts)
99. Module Summary
100. Module Resources
101. Docker Compose: Elegant Multi-Container Orchestration
102. Module Introduction
103. Docker-Compose: What & Why?
104. Creating a Compose File
105. Diving into the Compose File Configuration
106. Installing Docker Compose on Linux
107. Docker Compose Up & Down
108. Working with Multiple Containers
109. Adding Another Container
110. Building Images & Understanding Container Names
111. Docker Compose
112. Module Summary
113. Module Resources
114. Working with "Utility Containers" & Executing Commands In Containers
115. Module Introduction & What are "Utility Containers"?
116. Utility Containers: Why would you use them?
117. Different Ways of Running Commands in Containers
118. Building a First Utility Container
119. Utilizing ENTRYPOINT
120. Using Docker Compose
121. Utility Containers, Permissions & Linux
122. Module Summary
123. Module Resources
124. A More Complex Setup: A Laravel & PHP Dockerized Project
125. Module Introduction
126. The Target Setup
127. Adding a Nginx (Web Server) Container
128. Adding a PHP Container
129. Adding a MySQL Container
130. Adding a Composer Utility Container
131. Creating a Laravel App via the Composer Utility Container
132. Fixing Errors With The Next Lecture
133. Launching Only Some Docker Compose Services
134. Adding More Utility Containers
135. Docker Compose with and without Dockerfiles
136. Bind Mounts and COPY: When To Use What
137. Module Resources
138. Deploying Docker Containers
139. Module Introduction
140. From Development To Production
141. Deployment Process & Providers
142. Getting Started With An Example
143. Bind Mounts In Production
144. Introducing AWS & EC2
145. Connecting to an EC2 Instance
146. Important: Installing Docker on a Virtual Machine
147. Installing Docker on a Virtual Machine
148. Installing Docker on Linux in General
149. Pushing our local Image to the Cloud
150. Running & Publishing the App (on EC2)
151. Managing & Updating the Container / Image
152. Disadvantages of our Current Approach
153. From Manual Deployment to Managed Services
154. Important: AWS, Pricing and ECS
155. Deploying with AWS ECS: A Managed Docker Container Service
156. More on AWS
157. Updating Managed Containers
158. Preparing a Multi-Container App
159. Configuring the NodeJS Backend Container
160. Deploying a Second Container & A Load Balancer
161. Using a Load Balancer for a Stable Domain
162. Using EFS Volumes with ECS
163. Our Current Architecture
164. Databases & Containers: An Important Consideration
165. Moving to MongoDB Atlas
166. Using MongoDB Atlas in Production
167. Our Updated & Target Architecture
168. Understanding a Common Problem
169. Creating a "build-only" Container
170. Introducing Multi-Stage Builds
171. Building a Multi-Stage Image
172. Deploying a Standalone Frontend App
173. Development vs Production: Differences
174. Understanding Multi-Stage Build Targets
175. Beyond AWS
176. Module Summary
177. Module Resources
178. Docker & Containers - A Summary
179. Module Introduction
180. Images & Containers
181. Key Commands
182. Data, Volumes & Networking
183. Docker Compose
184. Local vs Remote
185. Deployment
186. Module Resources
187. Getting Started with Kubernetes
188. Module Introduction
189. More Problems with Manual Deployment
190. Why Kubernetes?
191. What Is Kubernetes Exactly?
192. Kubernetes: Architecture & Core Concepts
193. Kubernetes will NOT manage your Infrastructure!
194. A Closer Look at the Worker Nodes
195. A Closer Look at the Master Node
196. Important Terms & Concepts
197. Kubernetes Core Concepts
198. Module Resources
199. Kubernetes in Action - Diving into the Core Concepts
200. Module Introduction

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!

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.

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

1. Dive Into Docker!
2. Finished Code and Diagrams
3. Join Our Community!
4. Why Use Docker?
5. What is Docker?
6. Docker for Mac/Windows
7. Installing Docker on macOS
8. Installing Docker with WSL on Windows 10/11
9. Installing Docker on Linux
10. Using the Docker Client
11. But Really...What's a Container?
12. How's Docker Running on Your Computer?
13. Manipulating Containers with the Docker Client
14. Docker Run in Detail
15. Overriding Default Commands
16. Listing Running Containers
17. Container Lifecycle
18. Restarting Stopped Containers
19. Removing Stopped Containers
20. Retrieving Log Outputs
21. Stopping Containers
22. Multi-Command Containers
23. Executing Commands in Running Containers
24. The Purpose of the IT Flag
25. Getting a Command Prompt in a Container
26. Starting with a Shell
27. Container Isolation
28. Building Custom Images Through Docker Server
29. Creating Docker Images
30. Buildkit for Docker Desktop
31. Building a Dockerfile
32. Dockerfile Teardown
33. What's a Base Image?
34. The Build Process in Detail
35. A Brief Recap
36. Rebuilds with Cache
37. Tagging an Image
38. Quick Note for Windows Users
39. Manual Image Generation with Docker Commit
40. Making Real Projects with Docker
41. Project Outline
42. Node Server Setup
43. Reminder on Buildkit and using the Progress Flag
44. A Few Planned Errors
45. Base Image Issues
46. A Few Missing Files
47. Copying Build Files
48. Container Port Mapping
49. Specifying a Working Directory
50. Unnecessary Rebuilds
51. Minimizing Cache Busting and Rebuilds
52. Docker Compose with Multiple Local Containers
53. App Overview
54. App Server Starter Code
55. Assembling a Dockerfile
56. Introducing Docker Compose
57. Docker Compose Files
58. Networking with Docker Compose
59. Docker Compose Commands
60. Stopping Docker Compose Containers
61. Container Maintenance with Compose
62. Automatic Container Restarts
63. Container Status with Docker Compose
64. Creating a Production-Grade Workflow
65. Development Workflow
66. Flow Specifics
67. Docker's Purpose
68. Project Generation
69. More on Project Generation
70. Necessary Commands
71. Creating the Dev Dockerfile
72. Duplicating Dependencies
73. Starting the Container
74. Docker Volumes
75. WSL and Windows Users Must Read Before Next Lecture
76. Bookmarking Volumes
77. Shorthand with Docker Compose
78. Overriding Dockerfile Selection
79. Do We Need Copy?
80. Executing Tests
81. Live Updating Tests
82. Docker Compose for Running Tests
83. Shortcomings on Testing
84. Need for Nginx
85. Multi-Step Docker Builds
86. Implementing Multi-Step Builds
87. Running Nginx
88. Continuous Integration and Deployment with AWS
89. Services Overview
90. Github Setup
91. Important Info About Travis and Account Registration
92. Travis CI Setup
93. Travis YML File Configuration
94. A Touch More Travis Setup
95. Automatic Build Creation
96. Required AWS Elastic Beanstalk Environment Setup Updates - DO NOT SKIP
97. AWS Elastic Beanstalk
98. More on Elastic Beanstalk
99. Travis Config for Deployment
100. Required Update for IAM User and Keys
101. Automated Deployments
102. Exposing Ports Through the Dockerfile
103. Workflow With Github
104. Redeploy on Pull Request Merge
105. Deployment Wrapup
106. Environment Cleanup
107. AWS Configuration Cheat Sheet
108. Finished Project Code with Updates Applied
109. Building a Multi-Container Application
110. Single Container Deployment Issues
111. Application Overview
112. A Quick Note
113. Application Architecture
114. Worker Process Setup
115. Express API Setup
116. Important Update for pgClient and Table Query
117. Connecting to Postgres
118. More Express API Setup
119. Generating the React App
120. Fetching Data in the React App
121. Rendering Logic in the App
122. Exporting the Fib Class
123. Routing in the React App
124. "Dockerizing" Multiple Services
125. Checkpoint Files
126. Checkpoint Catchup
127. Expected Output for Latest Create React App Versions
128. Dockerizing a React App - Again!
129. Dockerizing Generic Node Apps
130. Postgres Database Required Fixes and Updates
131. Adding Postgres as a Service
132. Docker-compose Config
133. Environment Variables with Docker Compose
134. Required Worker Environment Variables
135. The Worker and Client Services
136. Nginx Path Routing
137. Routing with Nginx
138. Building a Custom Nginx Image
139. Starting Up Docker Compose
140. Nginx connect() failed - Connection refused while connecting to upstream
141. Troubleshooting Startup Bugs
142. WebSocket connection to 'ws://localhost:3000/ws' failed
143. Opening Websocket Connections
144. A Continuous Integration Workflow for Multiple Images
145. Production Multi-Container Deployments
146. Production Dockerfiles
147. Multiple Nginx Instances
148. Nginx fix for React Router
149. Altering Nginx's Listen Port
150. Cleaning Up Tests
151. Travis Configuration Setup
152. Fix for Failing Travis Builds
153. Github and Travis CI Setup
154. Pushing Images to Docker Hub
155. Successful Image Building
156. Multi-Container Deployments to AWS
157. Multi-Container Definition Files
158. Finding Docs on Container Definitions
159. Adding Container Definitions to DockerRun
160. More Container Definitions
161. Forming Container Links
162. Required AWS Elastic Beanstalk Environment Setup Updates - DO NOT SKIP
163. AWS Configuration Cheat Sheet - Updated for new UI
164. Creating the Elastic Beanstalk Environment
165. Managed Data Service Providers
166. Overview of AWS VPC's and Security Groups
167. RDS Database Creation
168. ElastiCache Redis Creation
169. Creating a Custom Security Group
170. Applying Security Groups to Resources
171. Setting Environment Variables
172. IAM Keys for Deployment
173. Travis Keys Update
174. Travis Deploy Script
175. Container Memory Allocations
176. Verifying Deployment
177. A Quick App Change
178. Making Changes
179. Cleaning Up AWS Resources
180. AWS Configuration Cheat Sheet
181. Finished Project Code with Updates Applied
182. Onwards to Kubernetes!
183. The Why's and What's of Kubernetes
184. Kubernetes in Development and Production
185. Docker Desktop's Kubernetes Setup and Installation - macOS
186. Docker Desktop's Kubernetes Setup and Installation - Windows
187. Updated Minikube Install and Setup Info - macOS
188. Minikube Setup on MacOS
189. Minikube Setup on Windows
190. Minikube Setup on Linux
191. Mapping Existing Knowledge
192. Quick Note to Prevent an Error
193. Adding Configuration Files
194. Object Types and API Versions
195. Running Containers in Pods
196. Service Config Files in Depth
197. Connecting to Running Containers
198. The Entire Deployment Flow
199. Imperative vs Declarative Deployments
200. Maintaining Sets of Containers with Deployments

*** Updated for latest CKAD (2022) 1.27 version of Exam ***

A Kubernetes Certification can take your career to a whole new level. Learn, practice, and get certified on Kubernetes with hands-on labs right in your browser.

"I passed the exam and certified CKAD now. I didn't passed at the first attempt. Second time, I found  this course on official page k8s and did practice all the labs. Honestly, labs are very challenging and great for the CKAD!" - Dave, Student.

Learning Kubernetes is essential for any DevOps professional. DevOps engineers are always in demand. Currently, the average Silicon Valley salary for a DevOps engineer is 20% higher than what a software engineer makes. DevOps engineers make an average of $140,000 to $200,000 annually. And one of the most in-demand skills is Kubernetes Deployment.

Kubernetes is an open-source system for automating the deployment, scaling, and management of containerized applications. It was originally designed by Google and is now maintained by the Cloud Native Computing Foundation.

                                                                                                    Simplify Complex Technology

Kubernetes is at the cutting edge of application deployment. To elevate your DevOps career, learn how to deploy applications on Kubernetes effectively.

This course helps you gain the knowledge required to design and deploy cloud-native applications on a Kubernetes cluster.  A series of well-designed lectures with animation and illustration help you understand complex concepts easily.

"Passed with a 70%, next up CKA​. Your teaching style is great​!" - Colin, Student

                                                                                                     Practice! Practice! Practice!

Lectures alone won’t help you clear the certification. The Kubernetes Certification is a practical hands-on exam. You need hands-on experience, to get fast, and to practice. That is what our integrated hands-on lab experience gives you. Our coding quizzes can be accessed right in your browser without having to set up any lab environment yourself. We validate your work and give you feedback instantly. Preview a few lab exercises for Free!!

"I completed my certification 75% on second attempt. Thanks to @Mumshad Mannambeth and others who helped me out.​" - Murali, Student

After you have completed the lectures and coding exercises, you will have the opportunity to complete a series of assignments that put your new skills to the test. You will be given the challenge to solve using the Kubernetes skills you have learned.

This will give you real-world experience and the chance to work with other students in the community. You will develop a Kubernetes deployment and get feedback for your work.

"Finally i passed ckad exam, my hearty thanks to @Mumshad Mannambeth, for his courses and guidance...it was helpful for me in the exam​" - Anish Seelan, Student

                                                                                                      Join Our Community!

Once you enroll in the course, you will get access to our community of teachers and learners on Slack, where we discuss important topics, tips, and tricks to pass the exam. This is a great place for you to clear your doubts and get answers to your questions instantly.

This course is the best way to get Certified in Kubernetes for an Absolute Beginner.

Don’t waste any more time wondering what course is best for you. You’ve already found it. Get started right away!

"Absolutely delighted the course/practice contents on this course!" - ThulasiRaman B V, Student

Legal Notice:

Kubernetes and the Kubernetes logo are trademarks or registered trademarks of The Linux Foundation. in the United States and/or other countries. The Linux Foundation and other parties may also have trademark rights in other terms used herein. This course is not certified, accredited, affiliated with, nor endorsed by Kubernetes or The Linux Foundation.

Course Update History

• June 15, 2023 – Lab environment upgrade to 1.27v

• Feb 2, 2023 – Lab environment upgrade to 1.26v

• Oct 10, 2022 – Lab environment upgrade to 1.24v

• Aug 27, 2022 – Lightning Labs and mock exam solutions added

• May 1, 2022 – Lab environment upgrade to 1.23v

• Oct 20, 2021 – Lab environment upgrade to 1.22v

• Sep 1, 2021 – Course Updates / Exam curriculum Update
  New lectures and labs added based on the new curriculum on topics mentioned below:
  Build, define, and modify container images
  Authentication, Authorization, and Admission Control
  KubeConfig
  API Groups
  Role-based access controls
  Understanding API deprecations
  Blue/Green or Canary deployments
  Helm
  Discovering and using resources that extend Kubernetes (CRD)

• May 10, 2021 – Lab environment upgrade to 1.20v

• Aug 24, 2020 – Lab environment upgrade to 1.19v

• Jun 16, 2020 – Lab environment upgrade to 1.18v

• Feb 20, 2020 – New lectures on working with kubectl outputs, Rolling updates, Rollbacks, and 2 new Lightening Labs were added.
  Mock Exams updated.

• Jan 2, 2020 – New lectures on Storage Classes, StatefulSets, and Volume Claim Templates were added.

• Jul 5, 2019 – New Mock Exam to the Kubernetes Certification Courses added

• Jan 2, 2019 – New lecture ConfigMaps added

• Dec 19, 2018 – New videos and practice tests on Service Accounts in Kubernetes added to the course

• Dec 13, 2018 – New lectures on Taints/Tolerations and Node Affinity added

• Dec 1, 2018 – Kubernetes Challenge Series Game of PODS added
  

1. Introduction
2. Introduction
3. Kubernetes Series
4. Kubernetes for Beginners Course
5. Certification Details
6. CNCF Certification
7. Download Course Deck
8. A note on Course Curriculum
9. Course release notes
10. Join our Slack Group
11. Core Concepts
12. Recap - Kubernetes Architecture
13. Docker-vs-ContainerD
14. Recap - Pods
15. YAML Basics
16. Recap - Pods with YAML
17. Recap - Demo - Creating Pods with YAML
18. Note!
19. Practice Test - Introduction
20. Demo: Accessing Labs
21. Accessing the Labs
22. Practice Test - Pods
23. Solution - Pods (optional)
24. Edit Pods
25. Recap - ReplicaSets
26. Practice Test - ReplicaSets
27. Solution - ReplicaSets (optional)
28. Recap - Deployments
29. Practice Test - Deployments
30. Solution - Deployments (optional)
31. Certification Tip: Formatting Output with kubectl
32. Recap - Namespaces
33. Practice Test - Namespaces
34. Solution - Namespaces (optional)
35. Certification Tip: Imperative Commands
36. Practice Test - Imperative Commands
37. Solution - Imperative Commands (optional)
38. Here's some inspiration to keep going
39. A Quick Reminder
40. Configuration
41. Define, build and modify container images
42. Practice test Docker Images
43. Commands and Arguments in Docker
44. Commands and Arguments in Kubernetes
45. A quick note on editing Pods and Deployments
46. Practice Test - Commands and Arguments
47. Solution - Commands and Arguments (Optional)
48. Environment Variables
49. ConfigMaps
50. Practice Test - ConfigMaps
51. Solution: ConfigMaps (Optional)
52. Secrets
53. A quick note about Secrets!
54. Practice Test - Secrets
55. Solution - Secrets (Optional)
56. Demo: Encrypting Secret Data at Rest
57. Docker Security
58. Security Contexts
59. Practice Test - Security Contexts
60. Solution: Security Contexts
61. Service Account
62. Practice Test - Service Acccount
63. Solution: Service Account
64. Resource Requirements
65. Practice Test - Resource Requirements
66. Solution: Resource Requirements
67. Taints and Tolerations
68. Practice Test - Taints and Toleration
69. Solution - Taints and Tolerations (Optional)
70. Node Selectors
71. Node Affinity
72. Practice Test - Node Affinity
73. Solution - Node Affinity (Optional)
74. Taints & Tolerations vs Node Affinity
75. Practice Test
76. Certification Tips - Student Tips
77. If you like it, Share it!
78. Multi-Container Pods
79. Multi-Container Pods
80. Practice Test - Multi-Container Pods
81. Solution - Multi-Container Pods (Optional)
82. Init Containers
83. Practice Test – Init Containers
84. Solution – Init Containers (Optional)
85. Observability
86. Readiness and Liveness Probes
87. Liveness Probes
88. Practice Test - Readiness and Liveness Probes
89. Solution: Readiness and Liveness Probes
90. Container Logging
91. Practice Test - Container Logging
92. Solution - Logging (optional)
93. Monitor and Debug Applications
94. Practice Test - Monitoring
95. Solution - Monitoring (optional)
96. POD Design
97. Labels, Selectors and Annotations
98. Practice Test - Labels, Selectors and Annotations
99. Solution - Labels and Selectors (optional)
100. Rolling Updates & Rollbacks in Deployments
101. Updating a Deployment
102. Demo - Deployments
103. Practice Test - Rolling Updates & Rollbacks
104. Solution - Rolling Updates (Optional)
105. Deployment Strategy - Blue Green
106. Deployment Strategy - Canary
107. Practice Test - Deployment strategies
108. Solution: Deployment strategies
109. Jobs
110. CronJobs
111. Practice Test - Jobs & CronJobs
112. Solution - Jobs and Cronjobs (optional)
113. Services & Networking
114. Services
115. Services - Cluster IP
116. Practice Test - Services
117. Solution - Services (optional)
118. Ingress Networking
119. Article: Ingress
120. Practice Test - Ingress Networking - 1
121. Solution: Ingress Networking - 1
122. FAQ - What is the rewrite-target option?
123. Practice Test - Ingress Networking - 2
124. Solution: Ingress Networking - 2
125. Network Policies
126. Developing network policies
127. Practice Test - Network Policies
128. Solution - Network Policies (optional)
129. State Persistence
130. Volumes
131. Persistent Volumes
132. Persistent Volume Claims
133. Using PVCs in Pods
134. Volumes Quiz
135. Practice Test - Persistent Volumes
136. Solution - Persistent Volume and Persistent Volume Claims (Optional)
137. Note on optional topics
138. Storage Classes
139. Practice Test - Storage Class
140. Why Stateful Sets?
141. Stateful Sets Introduction
142. Headless Services
143. Storage in StatefulSets
144. Security
145. Authentication, Authorization and Admission Control
146. Authentication
147. Article on Setting up Basic Authentication
148. Important Updates
149. KubeConfig
150. Practice Test KubeConfig
151. Solution KubeConfig
152. API Groups
153. Authorization
154. Role Based Access Controls
155. Practice Test Role Based Access Controls
156. Solution Role Based Access Controls
157. Cluster Roles
158. Practice Test Cluster Roles
159. Solution Cluster Roles
160. Admission Controllers
161. Labs - Admission Controllers
162. Solution: Admission Controllers
163. Validating and Mutating Admission Controllers
164. Labs - Validating and Mutating Admission Controllers
165. Solution: Validating and Mutating Admission Controllers
166. API Versions
167. API Deprecations
168. Lab - API Versions/Deprecations
169. Solution: API Versions
170. Custom Resource Definition
171. Practice Test - Custom Resource Definition
172. Custom Controllers
173. Operator Framework
174. Helm Fundamentals
175. Helm Introduction
176. Install Helm
177. Labs - Install Helm
178. Solution: Install Helm
179. Helm Concepts
180. Labs - Helm Concepts
181. Solution: Helm Concepts
182. Additional Practice - Kubernetes Challenges (Optional)
183. Kubernetes Challenges
184. Certification Tips
185. Time Management
186. Additional Tips
187. Lightning Labs
188. Introduction - Lightning Labs
189. Lightning Lab - 1
190. Solution: Lightning Lab1
191. Lightning Lab - 2
192. Solution: Lightning Lab - 2
193. Mock Exams
194. Mock Exam - 1
195. Mock Exam -1 (Solution)
196. Mock Exam - 2
197. Mock Exam -2 (Solution)
198. Bonus Lecture: Conclusion
199. Register for Certification