Top 8 Recommended Kubernetes Self-Study Materials! [November 2024]

***CNCF Endorsed Content***

*** Updated for latest CKA(2024) 1.30 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, 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

• July 15, 2024 - Lab environment upgrade to 1.30v

• Feb 17, 2024 – Lab environment upgrade to 1.29v

• 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

By the end of this course, you'll be ready to take the Certified Kubernetes Administrator (CKA) certification exam.

1. Introduction
2. Course Introduction
3. Certification
4. Certification Details
5. Course Release Notes
6. The Kubernetes Trilogy
7. Join our Community 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. Course setup - 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. Additional Resource
112. Practice Test - Secrets
113. Solution - Secrets (Optional)
114. Demo: Encrypting Secret Data at Rest
115. Scale Applications
116. Multi Container Pods
117. Practice Test - Multi Container Pods
118. Solution - Multi-Container Pods (Optional)
119. Multi-container Pods Design Patterns
120. InitContainers
121. Practice Test - Init Containers
122. Solution - Init Containers (Optional)
123. Self Healing Applications
124. If you like it, Share it!
125. Cluster Maintenance
126. Cluster Maintenance - Section Introduction
127. Download Presentation Deck
128. OS Upgrades
129. Practice Test - OS Upgrades
130. Solution - OS Upgrades (optional)
131. Kubernetes Software Versions
132. References
133. Cluster Upgrade Process
134. Demo - Cluster upgrade
135. Practice Test - Cluster Upgrade
136. Solution: Cluster Upgrade
137. Backup and Restore Methods
138. Working with ETCDCTL
139. Practice Test - Backup and Restore Methods
140. Solution - Backup and Restore
141. Practice Test Backup and Restore Methods 2
142. Solution: Backup and Restore 2
143. Certification Exam Tip!
144. References
145. Security
146. Security - Section Introduction
147. Download Presentation Deck
148. Kubernetes Security Primitives
149. Authentication
150. Article on Setting up Basic Authentication
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

***CNCF Endorsed Content***

“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

• Feb 17, 2024 – Lab environment upgrade to 1.29v

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

The Ultimate Kubernetes Course for Beginners: Now with Multilingual Subtitles!

Available with quality subtitles in Hindi, Spanish and English.

What is Kubernetes?

Kubernetes is the most powerful DevOps technology for managing (or orchestrating) the entire lifecycle of cloud applications. Google, for example, deploys more than 12 billion applications monthly based on Kubernetes, including well-known services such as Search, YouTube, Gmail, Google Play, Chrome, among others.

Currently, Kubernetes is a phenomenon in the technology sector, being adopted by the most innovative companies due to its versatility, security, and performance. With Kubernetes, it is possible to deliver new software and updates in record time, meeting the demands of the modern internet.

In summary, Kubernetes is a technology for orchestrating production-ready containers, according to the official definition of Kubernetes itself.

What is the difference between Kubernetes and GKE (Google), AKS (Azure), EKS (Amazon), ACK (Alibaba), among others?

The difference is significant, as GKE, AKS, EKS, and ACK are not Kubernetes themselves! Kubernetes is a container orchestration system, an independent, open, and free technology. This training will teach Kubernetes in its pure form, which can be fully reused in any environment with Kubernetes installed, whether locally or in the cloud.

In general terms, GKE, AKS, EKS, and ACK are products that use Kubernetes. They are provided as services by the companies Google, Microsoft, Amazon, and Alibaba, respectively, to create an environment (cluster) where you can run your Kubernetes applications outside your company, that is, in their cloud. This is known as Managed Kubernetes Platform.

In summary, Kubernetes is the underlying technology, while GKE, AKS, EKS, and ACK are managed services that facilitate the deployment and operation of Kubernetes clusters in their respective clouds. Each of these services has its own specific characteristics and integrations, allowing you to choose the most suitable for your needs. Learning Kubernetes is essential to stand out in the world of distributed cloud applications with containers, regardless of the chosen platform.

Therefore, GKE, AKS, EKS, and ACK are, in essence, environments to install Kubernetes. They charge for this service and offer other additional services to add value to your Kubernetes environment (cluster).

Who owns Kubernetes?

Kubernetes is an open-source project under the management of the Cloud Native Computing Foundation (CNCF). The CNCF is a sub-organization of the Linux Foundation, a non-profit entity that also oversees the development of the Linux operating system. Therefore, although Kubernetes is a community project with contributions from various organizations and individuals, governance and strategic guidance are provided by the CNCF and, ultimately, by the Linux Foundation.

Why should I learn Kubernetes?

Learning Kubernetes puts you at the forefront of the expanding market for distributed cloud applications that use containers. With this course, you will have the opportunity to equip yourself with the same powerful tools used by industry giants!

The most impressive thing is to know which other organizations, besides Google, are using Kubernetes to innovate their systems. NASA, Nubank, Spotify, Adidas, Tinder, Airbnb, Bloomberg Financial Data Analytics, and Udemy are just a few examples of leading companies in innovation and market power that use Kubernetes.

This course will not only give you a deep understanding of Kubernetes but will also provide you with practical skills that you can immediately apply in your work. Whether to improve the efficiency of your current organization or to increase your employability in the market, knowledge of Kubernetes is a valuable skill that can open many doors for you.

What will I have acquired upon completing this training?

This course will prepare you with comprehensive knowledge of Kubernetes, starting with the basics. You will understand what a container orchestrator is, what Kubernetes is, and the various possibilities of its use.

But we don’t stop there! This training will prepare you to manage the entire lifecycle of your application using Kubernetes. You will be able to handle the daily challenges that a Kubernetes administrator faces, acquiring professional skills to solve problems effectively and assertively.

At the end of this course, you will not only have a theoretical understanding of Kubernetes but will also have practical experience in solving real problems. This knowledge and experience will contribute to a successful career in the field of DevOps and help you stand out in the job market.

Course Structure

This course is structured based on an innovative neurolearning methodology. This pedagogical approach uses advanced teaching techniques that allow the student to absorb up to 70% more of the content of the technology under study, all with reduced mental effort.

The course content is organized around three fundamental pillars:

Understanding: What is Kubernetes? Here, you will understand the concept behind this powerful tool.

Application: Why use Kubernetes? In this pillar, we will discuss the purpose and advantages of using Kubernetes.

Practice: How to implement Kubernetes? Here, you will learn the practice of implementing and using Kubernetes in real-world scenarios.

The course is designed to be highly practical: 80% of the content is dedicated to practical classes, while the remaining 20% is reserved for theory and fundamental concepts. This approach ensures that you not only understand Kubernetes but are also ready to effectively apply it in your work environment.

Additionally, the course goes beyond the simple use of Kubernetes. It focuses on providing a deep understanding of what is happening behind the scenes. This will allow you to become a highly valuable professional, capable of handling complex situations and making informed decisions.

What professional level will I reach with this training, and how complete is the course?

This course offers initial professional training, preparing you to enter the job market as a Kubernetes Administrator (Initial Level). The training content has been carefully crafted so that you are able to handle various situations related to the daily operation of Kubernetes. The course is pedagogically balanced and covers:

Basic Themes: The course addresses all the fundamental aspects of Kubernetes.

Intermediate Themes: Includes common day-to-day operations.

Advanced Themes: Deals with some advanced topics, focusing only on the essential issues.

Final Course Project

The final project is an opportunity to apply all the knowledge acquired during the training in a professional manner. The challenge consists of the complete orchestration of a widely used professional system.

The course will provide all the necessary conditions for you to face this challenge with confidence. The project will be carried out step by step, with detailed explanations from the teacher, so that you can achieve the final goal: to orchestrate a professional application, managing the entire software lifecycle. This includes deploying the software in production, managing fundamental aspects, and finally, removing the application. This practical experience will equip you with the necessary skills to stand out in the field of DevOps.

Do I need to pay for a cloud service (Google, Azure, Amazon, Alibaba, etc.) to take this course?

No, you don’t need to! This course is based exclusively on FOSS (Free and Open Source Software) technologies. Therefore, you will not have to spend a single penny to use the technologies taught in this training, nor provide your credit card details to any company. We believe it is unacceptable for these large corporations to continue to monetize students.

In this course, we will use minikube, a system developed by the creators of Kubernetes themselves. Minikube creates a real (cluster) Kubernetes environment, complete with all the functionalities needed to run everything we need to learn in this training, and best of all, at no cost! This is because minikube is FOSS!

But what is minikube?

Minikube is a system specifically designed to teach and learn Kubernetes. The Cloud Native Computing Foundation (CNCF) and the Linux Foundation (CNCF partner and Kubernetes certifier) strongly recommend and encourage the use of minikube for learning.

Everything we study using minikube will work identically in any environment where Kubernetes is installed, whether in a public cloud (Google, Azure, Amazon, Alibaba, etc.), a Raspberry Pi, a Virtual Machine, or Bare Metal (physical servers), for example.

What do I need to know before taking this course?

Before enrolling in this course, it is important that you have knowledge in three main areas:

Docker: This course assumes that you are already familiar with Docker, as it will not be covered here.

Computer networks: It is necessary to understand the basic concepts of computer networks, including TCP/IP, DHCP, DNS, Proxy, and Load Balancer.

GNU/Linux: We recommend that you have basic knowledge of GNU/Linux.

Is this course suitable for the Certified Kubernetes Administrator (CKA) certification?

This course is essential for those intending to take the CKA certification exam. It covers the concepts, features, and components that are part of the exam. However, we recommend additional studies and mock exams before taking the exam, as this course does not include mock exams.

About the instructor

The course is taught by Prof. Eng. Arnaldo Sousa, who has a background in Software Engineering, IT Management, and Systems Analysis and Development. He has served as an official instructor and consultant for IBM and Sun Microsystems (now Oracle), and is a licensed teacher with various specializations in the field of education, including Teaching, Communication, Neurolearning, Neuropsychology, Philosophy, and Special Education.

With extensive experience in using and teaching new technologies, Professor Arnaldo Sousa will present Kubernetes in an extremely comprehensible and accessible way!

Ready to take your career to the next level with Kubernetes? Don’t miss out on this opportunity to master the most sought-after skills in the industry. Enroll now and start your journey towards becoming a Kubernetes expert!

1. Getting Started
2. Overview and Course Goals
3. Course Wallpapers
4. The Professor
5. I don't know Docker, will I be able to understand this course?
6. Prerequisites
7. Important!
8. History of Kubernetes
9. Setup for Windows Users
10. antiX Linux, VM for Windows users
11. Oracle VirtualBox
12. Downloads for antiX Linux VM
13. Oracle VirtualBox installation
14. antiX VM Configuration (OVA file)
15. antiX Linux Overview
16. Keyboard and Time Zone configuration on antiX Linux
17. VirtualBox Shared Folders
18. Information for GNU/Linux Users
19. FeatherPad Editor
20. Kubernetes Setup
21. Installation and Configuration Commands
22. Docker Installation
23. minikube - Local Kubernetes Cluster
24. Versions of kubectl and minikube used in this course
25. kubectl Installation
26. minikube Installation
27. Fundamentals and Concepts
28. What is a container orchestrator?
29. Popular orchestrators (Docker Swarm, Apache Mesos, OpenShift and Kubernetes)
30. Kubernetes Immutability Concept
31. Fundamentals Quiz
32. Availability - Part 1 - Declarative Settings
33. Availability - Part 2 - DevOps Relationship
34. Scalability - Infrastructure, Services, and DevOps Teams
35. Infrastructure Abstraction
36. Infrastructure Abstraction Quiz
37. Components
38. Control Plane
39. kube-apiserver
40. cloud-controller-manager
41. controller-manager
42. etcd - Cluster Persistence Storage
43. kube-proxy
44. Kubernetes Pods Concept
45. kube-scheduler
46. kubelet
47. Container Runtime Interface (CRI)
48. YAML
49. YAML - Introduction
50. YAML - Overview
51. YAML - Main Uses: Persistence, Docker Compose and Kubernetes
52. YAML - Basic Structure
53. YAML on Kubernetes
54. Pods
55. Exercising - Learn by doing!
56. Creating Pods - Imperative Form
57. Creating Pods - Manifest Files
58. Optional Exercise
59. ReplicaSets
60. Exercising - Learn by doing!
61. ReplicaSet Concept and Creation
62. ReplicaSet Controlling Pods
63. ReplicaSet Scale - Manifest File
64. ReplicaSet Scale - Imperative Form
65. Deployments
66. Deployments Section Overview
67. Introduction to Kubernetes Deployments
68. Exercising - Learn by doing!
69. Creating the Deployment Resource
70. Deployment Rollout
71. Rolling Update Strategy - Deep Analysis
72. Removing Deployment Resources
73. Rollout History
74. Deployment Rollback
75. Rollout Pause & Rolout Resume
76. Deployment Scale: YAML & Imperative Form
77. Recreate Strategy Type
78. Kubernetes Networking Infrastructure
79. Container to Container Communication
80. Intra-Node Pod Network Communication
81. INTER-Node Pod Network Communication
82. Exercising - Learn by doing!
83. Pod Communication Test — Part 1
84. Pod Communication Test — Part 2
85. Namespaces
86. Introduction to Namespaces
87. Exercising - Learn by doing!
88. Namespace Creation
89. Namespace Deletion
90. Current Context Namespace
91. Namespaces Manifest Files
92. Namespace Field Definition
93. Services
94. Introduction to Kubernetes Services
95. Availability of Services
96. ClusterIP Default Service
97. ClusterIP - Communication between "port" and "targetPort"
98. Exercising - Learn by doing!
99. ClusterIP Service Creation
100. Consuming ClusterIP Service
101. ClusterIP Details, and Mass Resource Deletions
102. NodePort Service
103. NodePort Services Port Details: Mandatory, Optional , Omitted, Random
104. NodePort Service Creation
105. Troubleshooting — NodePort Service Connection Error
106. External NodePort Service Consumption
107. Ways to Get Node IP Address
108. NodePort Service Removal
109. Introduction to Advanced Services
110. LoadBalancer Service
111. LoadBalancer Service - Create, Consume, and Remove
112. Introduction to ExternalName Services
113. DNS Resolution for ExternalName Services - Overview
114. DNS Lookup Services
115. LivenessProbe
116. Liveness Probes Section Overview
117. Introduction to Kubernetes Liveness Probes
118. Exercising - Learn by doing!
119. Implementing Liveness Probes and Sanity Logic
120. Putting Liveness Probes into Action!
121. Resource Management
122. Section Overview
123. Requests
124. Exercising - Learn by doing!
125. Requests Implementation
126. Limits
127. Requests and Limits: Pods with Multiple Containers
128. Volumes
129. Section Overview
130. Introduction to Kubernetes Volumes
131. Exercising - Learn by doing!
132. Creating Ephemeral Volumes - emptyDir
133. Creating Persistent Volumes - hostPath
134. PersistentVolume, PersistentVolumeClaim, VolumeClaimTemplates and Storage Class
135. DaemonSets
136. DaemonSets Section Overview
137. Introduction to Kubernetes DaemonSets
138. Exercising - Learn by doing!
139. Adding Worker Nodes and Creating DaemonSet Pods
140. Multi-Mode minikube Troubleshooting Guidance
141. Troubleshooting: minikube Multi-Nodes
142. DaemonSet Orphan Pods
143. Cascade Orphan Pods Option
144. Adoption of DaemonSet Pods
145. DaemonSet Pods on Speficic Nodes
146. DaemonSet Pods on Specific Nodes using Node Labels
147. DaemonSet Direct Nodes Attribution
148. Pods using Direct Nodes Attribution
149. Pods using Node Labels
150. Rolling Update DaemonSet Update Strategy
151. OnDelete DaemonSet Update Strategy
152. Important Notes about DaemonSet Update Strategy
153. Jobs
154. Jobs Section Overview
155. Attention to Job Technical Specifications
156. Introduction to Kubernetes Jobs
157. Container Exit Codes
158. Container Restart Policy
159. Restart Policy Values
160. Restart Policy Application
161. Failed Job Pods
162. Challenge: Using Jobs to Generate Lucky Numbers
163. Exercising - Learn by doing!
164. Creating Jobs for Generating Lucky Numbers
165. Lucky Numbers Generation Job Analysis
166. CronJobs
167. CronJobs Section Overview
168. Introduction to Kubernetes CronJobs
169. Basic Structure of Kubernetes CronJob
170. CronJob API
171. Kubernetes Cron Schedule Syntax
172. CronJob Special Strings
173. Schedule Cron & Crontab Guru
174. Exercising - Learn by doing!
175. Creating and Running a Kubernetes CronJobs
176. Kubernetes CronJobs Events, History Limits & Executions
177. Identifications: CronJobs > Jobs > Pods
178. Additional Cron Resources
179. ConfigMaps
180. Overview das Seções ConfigMaps e Secrets
181. Introduction to Kubernetes ConfigMaps
182. General ConfigMaps Specifications
183. Exercising - Learn by doing!
184. Creating ConfigMap
185. ConfigMap Mapping - Env Variable
186. Atualização de ConfigMap - Env Variable
187. Consuming ConfigMap through Container Command
188. Creating ConfigMap with ReadOnly Volume
189. ConfigMap Details with ReadOnly Volume
190. ConfigMap Update with ReadOnly Volume
191. ConfigMap File Properties
192. Parameter File-Based ConfigMaps
193. Immutable ConfigMaps
194. Implementing Immutable ConfigMaps
195. Secrets
196. Introduction to Kubernetes Secrets
197. Secrets Consumption – Base64 & Arbitrary Strings
198. Exercising - Learn by doing!
199. Creating Secret: data Field and Base64 Operations
200. Opaque, stringdata Field, immutable

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

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