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

***Docker Endorsed Content***

Docker is an open platform for developers and sysadmins to build, ship, and run distributed applications, whether on laptops, data center VMs, or the cloud.

This course introduces Docker to an Absolute Beginner using really simple and easy-to-understand lectures. Lectures are followed by demos showing how to set up and get started with Docker. The coding exercises that accompany this course will help you practice Docker commands, develop your own images using Dockerfiles, and practice Docker Compose. You will be developing Docker files for different use cases right in your browser. This way, you don’t really need to have your own environment set up to get some hands-on practice. The coding exercises will validate your commands and Dockerfiles and ensure you have written them correctly.

And finally, we have assignments to put your skills to the test. You will be given the challenge to solve using the skills you gained during this course. This is a great way to gain real-life project experience and work with the other students in the community to develop a Dockerfile and get feedback for your work. The assignment will push you to research and develop your own Docker images.

Our tools, courses, and resources will help you improve your Docker skills and help you gain a true understanding of the program.

1. Introduction
2. Introduction
3. Docker Overview
4. Getting started with Docker
5. A note on installing Docker
6. Demo - Setup and Install Docker
7. A Quick Reminder
8. Resources
9. Student Preferences
10. Join our Community Channel for support and interaction
11. Docker Commands
12. Basic Docker Commands
13. Demo - Docker Commands
14. Download Course Deck
15. Demo - Docker Labs
16. Demo - Accessing labs
17. Course setup - accessing the labs
18. Labs - Basic Docker Commands
19. Docker Run
20. Docker Run
21. Article on Jenkins Image
22. Demo - Advanced Docker Run Features
23. Labs - Docker Run
24. Docker Images
25. Docker Images
26. Demo - Creating a new Docker Image
27. Labs - Docker Images
28. Environment Variables
29. Labs - Environment Variables
30. Command vs Entrypoint
31. Labs - Command vs Entrypoint
32. Docker Compose
33. Docker Compose
34. Pre-Requisite - YAML
35. Demo - Example Voting Application
36. Demo - Example Voting Application with Docker Compose
37. Demo - Docker Compose
38. Labs: Docker Compose
39. References
40. Stay Updated!
41. Docker Registry
42. Docker Registry
43. Lab: Docker Registry
44. Docker Engine, Storage and Networking
45. Docker Engine
46. Docker PID - Demo
47. Docker Storage
48. Docker Storage - Demo
49. Labs - Docker Storage
50. Docker Networking
51. Labs - Docker Networking
52. Docker on Mac & Windows
53. Docker on Windows
54. Demo - Docker on Windows
55. References
56. Docker on MAC
57. Container Orchestration - Docker Swarm & Kubernetes
58. Container Orchestration
59. Docker Swarm
60. Kubernetes Introduction
61. Conclusion
62. Conclusion
63. Course Completion Certificate
64. Bonus Lecture - Docker Certification Course

Proud to be a DOCKER ENDORSED course and instructor for 2024!

Now also a CNCF ENDORSED course and instructor in 2024!

2023 Update: New CI examples with 18 lectures showing you how to automate Docker and Kubernetes in GitHub Actions, including vulnerability scanning, advanced image building, multi-platform builds, and more. Kubernetes sections were also updated to reflect CLI updates and 5 new videos on inspecting resources.

2022 Update: Refreshed install and config videos, and more support for Apple Silicon (M1 arm64) and Raspberry Pi's!

Be ready for the Dockerized future with the number ONE Docker + Kubernetes mega-course on Udemy. Welcome to the most complete and up-to-date course for learning and using containers end-to-end, from development and testing, to server deployments and production. Taught by an award-winning Docker Captain and DevOps consultant.

Just starting out with Docker? Perfect. This course starts out assuming you're new to containers.

Or: Using Docker now and need to deal with real-world problems? I'm here for you! See my production topics around Swarm, Kubernetes, secrets, logging, rolling upgrades, and more.

BONUS: This course comes with Slack Chat, Discord Chat server, and live monthly YouTube Q&As with me!

"I've followed another course on (Udemy). This one is a million times more in depth." "...when it comes to all the docker stuff, this is the course you're gonna want to take" - Student Udemy Review

Why should you learn from me? Why trust me to teach you the best ways to use Docker?   (Hi, I'm Bret, please allow me to talk about myself for a sec):

• I'm A Practitioner. Welcome to the real world: I've got 20 years of sysadmin and developer experience, over 30 certifications, and have been using Docker and the container ecosystem for my consulting clients and my own companies since Docker's early days. Learn from someone who's run hundreds of containers across dozens of projects and organizations.

• I'm An Educator. Learn from someone who knows how to make a syllabus: I want to help you. People say I'm good at it. For the last few years, I've trained thousands of people on using Docker in workshops, conferences, and meetups. See me teach at events like DockerCon, O'Reilly Velocity, GOTO Conf, and Linux Open Source Summit. I hope you'll decide to learn with me, and join the fantastic online Docker community.

• I Lead Communities. Also, I'm a Docker Captain, meaning that Docker Inc. thinks I know a thing or two about Docker and that I do well in sharing it with others. In the real-world: I help run two local meetups in our fabulous tech community in Norfolk/Virginia Beach USA. I help online: usually in Slack, Discord, and Twitter, where I learn from and help others.

"Because of the Docker Mastery course, I landed my first DevOps job. Thank you Captain!" - Student Ronald Alonzo

"There are a lot of Docker courses on Udemy -- but ignore those, Bret is the single most qualified person to teach you." - Kevin Griffin, Microsoft MVP

Giving Back: a portion of my profit on this course will be donated to supporting open source and protecting our freedoms online! This course is only made possible by the amazing people creating open source. I'm standing on the shoulders of (open source) giants! Donations will be split between my favorite charities including the Electronic Frontier Foundation and Free Software Foundation. Look them up. They're awesome!

This is a living course and will be updated as Docker and Kubernetes features change.

This course is designed to be fast at getting you started but also get you deep into the "why" of things. Simply the fastest and best way to learn the latest container skills. Look at the scope of topics in the Session and see the breadth of skills you will learn.

Also included are Slack and Discord servers with 50k+ students for getting help with this course and continuing your Docker and DevOps learning with help from myself and other students.

"Bret's course is a level above all of those resources, and if you're struggling to get a handle on Docker, this is the resource you need to invest in." - Austin Tindle, Course Student

Some of the many cool things you'll do in this course:

• Edit web code on your machine while it's served up in a container

• Lock down your apps in private networks that only expose necessary ports

• Create a 3-node Swarm cluster in the cloud

• Install Kubernetes and learn the leading server cluster tools

• Use Virtual IP's for built-in load balancing in your cluster

• Optimize your Dockerfiles for faster building and tiny deploys

• Build/Publish your own custom application images

• Learn the differences between Kubernetes and Swarm

• Create your own image registry

• Use Swarm Secrets to encrypt your environment configs, even on disk

• Deploy container updates in a rolling always-up design

• Create the config utopia of a single set of YAML files for local dev, CI testing, and prod cluster deploys

• And so much more...

After taking this course, you'll be able to:

• Use Docker in your daily developer and/or sysadmin roles

• Deploy apps to Kubernetes

• Make Dockerfiles and Compose files

• Build multi-node Swarm clusters and deploying H/A containers

• Make Kubernetes YAML manifests and deploy using infrastructure-as-code methods

• Build a workflow of using Docker in dev, then test/CI, then production with YAML

• Protect your keys, TLS certificates, and passwords with encrypted secrets

• Keep your Dockerfiles and images small, efficient, and fast

• Run apps in Docker, Swarm, and Kubernetes and understand the pros/cons of each

• Develop locally while your code runs in a container

• Protect important persistent data in volumes and bind mounts

• Lead your team into the future with the latest Docker container skills!

Extra things that come with this course:

• Access to the course Slack team, for getting help/advice from me and other students.

• Bonus videos I put elsewhere like YouTube, linked to from this course's resources.

• Join me on weekly DevOps Live streams and demos on YouTube Live.

• Tons of reference links to supplement this content.

• Updates to content as Docker changes their features on these topics.

1. Quick Start!
2. What is Docker in 2023? The Three Innovations
3. Quick Container Run
4. Why Docker? Why Now in 2023?
5. Course Introduction
6. Course Roadmap (overview)
7. Getting Course Resources (GitHub Repo)
8. Course Chat with Students Learning Containers
9. YouTube Live Q&A with Bret
10. The Big FAQ
11. The Best Way to Setup Docker for Your OS
12. Installing The Right Docker for this course
13. Installing Docker: The Fast Way
14. Docker for Windows: Setup and Tips
15. Docker for Mac: Setup and Tips
16. Docker for Linux Desktop: Setup and Tips
17. Docker for Linux Server: Setup and Tips
18. VS Code for DevOps, Docker, and YAML Editing
19. Docker Version and Products Changes
20. Creating and Using Containers Like a Boss
21. Check Our Docker Install and Config
22. Starting a Nginx Web Server
23. Debrief: What Happens When We Run a Container
24. Container VS. VM: It's Just a Process
25. Windows Containers: Should You Consider Them?
26. Assignment: Manage Multiple Containers
27. Assignment Answers: Manage Multiple Containers
28. Container Commands
29. What's Going On In Containers: CLI Process Monitoring
30. Use MariaDB rather than MySQL
31. Getting a Shell Inside Containers: No Need for SSH
32. Docker Networks: Concepts for Private and Public Comms in Containers
33. FIXME: Change In Official Nginx Image Removes Ping
34. Docker Networks: CLI Management of Virtual Networks
35. Docker Networks: DNS and How Containers Find Each Other
36. More Container Commands
37. Assignment: Using Containers for CLI Testing
38. Assignment Answers: Using Containers for CLI Testing
39. Changes To Upcoming Assignment
40. Assignment: DNS Round Robin Test
41. Assignment Answers: DNS Round Robin Test
42. Container Images, Where To Find Them and How To Build Them
43. What's In An Image (and What Isn't)
44. The Mighty Hub: Using Docker Hub Registry Images
45. Images and Their Layers: Discover the Image Cache
46. Image Tagging and Pushing to Docker Hub
47. Building Images: The Dockerfile Basics
48. Building Images: Running Docker Builds
49. Building Images: Extending Official Images
50. Images
51. Assignment: Build Your Own Dockerfile and Run Containers From It
52. Assignment Answers: Build Your Own Dockerfile and Run Containers From It
53. Using Prune to Keep Your Docker System Clean (YouTube)
54. Persistent Data: Volumes, Volumes, Volumes
55. Container Lifetime & Persistent Data
56. Persistent Data: Data Volumes
57. Shell Differences for Path Expansion
58. Persistent Data: Bind Mounting
59. Persistent Data
60. Database Passwords in Containers
61. Updated Postgres Version for Next Video Assignment
62. Assignment: Database Upgrades with Named Volumes
63. Assignment Answers: Update for Recent Postgres Changes
64. Assignment Answers: Database Upgrades with Named Volumes
65. File Permissions Across Multiple Containers
66. Assignment: Edit Code Running In Containers With Bind Mounts
67. Assignment Answers: Edit Code Running In Containers With Bind Mounts
68. Making It Easier with Docker Compose: The Multi-Container Tool
69. Docker Compose and The docker-compose.yml File
70. Compose V2
71. Trying Out Basic Compose Commands
72. Version Dependencies in Multi-Tier Apps
73. Compose Assignments
74. Compose-Assignment-1: Build a Compose File For a Multi-Container Project
75. Compose-Assignment-1 Answers: Build a Compose File For a Multi-Container Project
76. Adding Image Building to Compose Files
77. Using MariaDB rather than PostgreSQL
78. Compose-Assignment-2: Compose For Image Building
79. Compose-Assignment-2 Answers: Compose For Image Building
80. Docker Compose
81. Swarm Intro and Creating a 3-Node Swarm Cluster
82. Swarm Mode: Built-In Orchestration
83. Create Your First Service and Scale It Locally
84. UI Change For Service Create/Update
85. Use Multipass to create Docker, Swarm, and K8s VMs
86. Creating a 3-Node Swarm Cluster
87. Swarm Mode Basics
88. Swarm Basic Features and How to Use Them In Your Workflow
89. Sections Requirements for Swarm, Drupal, and Postgres
90. Scaling Out with Overlay Networking
91. Scaling Out with Routing Mesh
92. Docker Swarm Networking
93. Assignment: Create A Multi-Service Multi-Node Web App
94. Assignment Answers: Create A Multi-Service Multi-Node Web App
95. Swarm Stacks and Production Grade Compose
96. Secrets Storage for Swarm: Protecting Your Environment Variables
97. Using Secrets in Swarm Services
98. Using Secrets with Swarm Stacks
99. Assignment: Create A Stack with Secrets and Deploy
100. Assignment Answers: Create A Stack with Secrets and Deploy
101. Swarm App Lifecycle
102. Using Secrets With Local Docker Compose
103. Full App Lifecycle: Dev, Build and Deploy With a Single Compose Design
104. Service Updates: Changing Things In Flight
105. Healthchecks in Dockerfiles
106. Swarm App Lifecycle
107. Info on Swarm Mastery
108. Container Registries: Image Storage and Distribution
109. Docker Hub: Digging Deeper
110. Understanding Docker Registry
111. Run a Private Docker Registry
112. Assignment: Secure Docker Registry With TLS and Authentication
113. Using Docker Registry With Swarm
114. Third Party Image Registries
115. Container Registries
116. Docker in Production
117. My DockerCon Talk on Docker and Swarm in Production
118. The Future of Swarm
119. Swarm Raft Quorum and Recovery (Laura Frank from DockerCon 2017)
120. The What and Why of Kubernetes
121. Kubernetes Intro
122. What Is Kubernetes
123. Why Kubernetes
124. Kubernetes vs Swarm
125. The What and Why of Kubernetes
126. Kubernetes Architecture and Install
127. Section Intro
128. Kubernetes Architecture Terminology
129. Kubernetes Local Install
130. Kubernetes Container Abstractions
131. Kubernetes Architecture and Install
132. Your First Pods
133. Kubectl run, create, and apply
134. Your First Pod With kubectl run
135. Cheat Sheets for Kubectl
136. Your First Deployment With kubectl create
137. Scaling ReplicaSets
138. 1.18 Changes to Kubectl Run
139. Your First Pods
140. Inspecting Kubernetes Resources
141. Section Intro
142. Inspecting Resources with Get
143. Inspecting Resources with Describe
144. Watching Resources
145. Container Logs in Kubernetes
146. Inspecting Kubernetes Resources
147. Exposing Kubernetes Ports
148. Section Intro
149. Service Types
150. MicroK8s and DNS for Services
151. Creating a ClusterIP Service
152. Running Netshoot in Kubernetes
153. Creating a NodePort and LoadBalancer Service
154. Kubernetes Services DNS
155. Kubernetes Management Techniques
156. Section Intro
157. YAML Generators in kubectl Commands
158. Imperative vs. Declarative
159. Three Management Approaches
160. Moving to Declarative Kubernetes YAML
161. Section Intro
162. Kubectl apply
163. Kubernetes Configuration YAML
164. Building Your YAML Files
165. Building Your YAML Spec
166. Dry Run CLI Changes
167. Dry Runs and Diff's
168. Labels and Label Selectors
169. Your Next Steps and The Future of Kubernetes
170. Section Intro
171. Storage in Kubernetes
172. Ingress
173. CRD's and The Operator Pattern
174. Higher Deployment Abstractions
175. Kubernetes Dashboard
176. Namespaces and Context
177. Future of Kubernetes
178. Automated CI Workflows
179. Section Intro: Automation
180. The Pull Request
181. Automation is the Glue of DevOps
182. Basic PR Workflow
183. Intermediate PR Workflow
184. Advanced PR Workflow
185. GitHub Actions Workflow Examples
186. Section Intro
187. Assignments for this Section
188. Add Basic Docker Build
189. Add BuildKit Cache
190. Add Multi-Platform Builds
191. Add Metadata and Dynamic Tags
192. Add GitHub Comments
193. Add CVE Scanning of Images
194. Add CVE Scan Blocking
195. Add Unit & Integration Testing
196. Add Kubernetes Smoke Test
197. Bonus: Add Job Parallelization to GHA
198. Implement These Automations
199. Docker Security Good Defaults and Tools
200. Section Intro: Top 10 Security Steps for Docker

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

This course is specifically designed for the aspirants who intend to give the "Docker Certified Associate" certification as well as for individuals who intend to gain  strong foundation into Docker and Container technologies.

The course is designed from absolute scratch which makes it a go-to course for any individual who is new into the field of Dockers and Containers.

Since this course is based on the official certification blueprint, this course also has a dedicated Exam Preparation section with a series of practice tests to verify the candidate's understanding of the topics discussed in the course and also verify if the candidate is ready to give the official certification exams.

Keeping the standards high similar to other best-seller courses of Zeal, this course has a perfect balance, and every topic is explained in a simplified way with practical scenarios.

With tons of practicals, easy-to-understand videos, and a dedicated exam preparation section, this course is all you need to gain a deeper understanding of Docker and ace the Docker Certified Associate" certification.

With this exciting set of learnings and practicals, I look forward to seeing you in this course and be part of your journey into Containers and getting DCA certified.

1. Section 1 - Getting Started with Dockers
2. Overview of the Course
3. Note - New Certification Page
4. PPT Notes - Docker Certified Associate
5. Introduction to Docker Containers
6. Our Community
7. Installation Methods for Docker
8. Creating Infrastructure for Docker Setup
9. Installing Docker in Linux
10. Document - Linux Installation Commands
11. Installing Docker Desktop
12. Document - Docker Desktop
13. Docker Image vs Docker Containers
14. Container Identification
15. Port Binding
16. Attached and Detached Modes
17. Removing Docker Containers
18. New Docker CLI Commands
19. docker container exec
20. Importance of IT flags
21. Default Container Commands
22. Overriding Default Container Commands
23. Restart Policies in Docker
24. Removing Docker Container Images
25. Disk Usage Metrics for Docker Components
26. Automatically Delete Container on Exit
27. Section 2 - Image Creation, Management, and Registry
28. Working with Docker Images
29. Overview of Dockerfile
30. Document - Dockerfile
31. COPY vs ADD Instructions
32. EXPOSE Instruction
33. Dockerfile - HEALTHCHECK Instruction
34. HEALTHCHECK Instruction Options
35. Document - HealtCheck Document Resource
36. Dockerfile - ENTRYPOINT Instruction
37. Dockerfile - WORKDIR Instruction
38. Document - WORKDIR Code
39. Dockerfile - ENV Instruction
40. Document - ENV Instruction Code
41. Tagging Docker Images
42. Docker Commit
43. Layers of Docker Image
44. Managing Images with CLI
45. Inspecting Docker Images
46. Pruning Docker Images
47. Flattening Docker Images
48. Overview of Docker Registries
49. Pushing Images to Central Repository
50. Applying Filters for Docker Images
51. Moving Images Across Hosts
52. Document - Docker Save and Docker Load
53. Build Cache
54. Document - Sample Code for Layer Caching
55. Section 3 - Networking
56. Overview of Docker Networking
57. Understanding Bridge Networks
58. Implementing User-Defined Bridge Networks
59. Understanding Host Network
60. Implementing None Network
61. Publish All Argument for Exposed Ports
62. Legacy Approach for Linking Containers
63. Section 4 - Orchestration
64. Overview of Container Orchestration
65. Overview of Docker Swarm & Building Labs
66. Document - Docker Script
67. Initializing Docker Swarm
68. Document - Initializing Swarm Cluster
69. Services, Tasks and Containers
70. Document - Replicated Service CLI Command
71. Scaling Swarm Service
72. Document - Scaling Service CLI Command
73. Multiple Approaches to Scale Swarm Services
74. Document - Multiple Approaches for Scaling
75. Replicated vs Global Service
76. Document - Global Service CLI Command
77. Draining Swarm Node
78. Document - Drain CLI Commands
79. Inspecting Swarm Service and Nodes
80. Document - Inspecting Services and Nodes
81. Adding Network and Publishing Ports to Swarm Tasks
82. Document - Publish Port at Service
83. Overview of Docker Compose
84. Document - Docker Compose YAML
85. Deploying Multi-Service Application in Swarm
86. Document - Docker Stack CLI commands
87. Locking Swarm Cluster
88. Document - AutoLock Commands
89. Troubleshooting Swarm Service Deployments
90. Mounting Volumes via Swarm
91. Document - Mount Volumes with Swarm
92. Control Service Placement
93. Document - Setting Constraints
94. Overview of Overlay networks
95. Creating Custom Overlay Networks for Swarm
96. Document - Custom Overlay Networks
97. Secure Overlay Networks
98. Creating Swarm Services using Templates
99. Split Brain & Importance of Quorum
100. High Availability of Swarm Manager Nodes
101. Running Manager-Only nodes in Swarm
102. Recover from losing the quorum
103. Document - Forcing New Cluster
104. Docker System Commands
105. Important Note - Kubernetes Series
106. Introduction to Kubernetes
107. Installation Options for Kubernetes
108. Using Managed Kubernetes Service from CSP
109. Document - MSSP
110. Overview of kubectl
111. Document - kubectl
112. Installing & Configuring kubectl for Linux and macOS
113. Understanding PODS
114. Understanding Kubernetes Objects
115. Creating First POD Configuration in YAML
116. Code - POD YAML
117. Introduction to Labels and Selectors
118. Implementing Labels and Selectors
119. Document - Labels and Selectors
120. Overview of ReplicaSets
121. Creating our first ReplicaSet
122. Code - ReplicSets
123. Introduction to Deployments
124. Creating our first deployment
125. Code - Deployments
126. maxSurge and maxUnavailable
127. Document - Deployment Configuration
128. Kubernetes Secrets
129. Code - Commands for Generating Secrets
130. Mounting Secrets Inside Pods
131. Code - Mounting Secrets in Pods
132. Understanding ConfigMaps
133. Code - ConfigMaps
134. Overview of Service
135. Creating First Service and Endpoint
136. Code - Service Deployment
137. Service Type: ClusterIP
138. Using Selectors for Service Endpoints
139. Code - Service and Selectors
140. Service Type: NodePort
141. Code - NodePort
142. Kubernetes Networking Model
143. Understanding Liveness Probe
144. Document - Liveness Probe
145. Understanding Readiness Probe
146. Document - Readiness Probe
147. Understanding DaemonSets
148. Document - Daemonsets
149. Taints and Tolerations
150. Code - Taints and Tolerations
151. Requests and Limits in Kubernetes
152. Code - Resource Limits
153. Network Policies
154. Code - Network Policies
155. Section 5 - Installation and Configuration of Docker EE
156. Important Note - Docker EE
157. Overview of Docker Enterprise Edition
158. Installing Docker EE
159. Document - Docker EE Installation Steps
160. Universal Control Plane
161. Document - Installing Docker UCP
162. Deploying Global Services in Swam via UCP
163. UCP - Access Control
164. Overview of Docker Trusted Registry
165. Installing DTR & Integrating with UCP
166. Document - Installation of Docker DTR
167. Un-Installation steps for DTR
168. Document - Un-Installing DTR
169. Configuring Trusted CA and Pushing Images to DTR
170. Document - Configuring Trusted CA and Pushing Images to DTR
171. Overview of DTR Backup
172. Document - DTR Backup Command
173. DTR Backup - Images
174. Overview of Swarm Routing Mesh
175. Implementing Swarm Routing Mesh
176. DTR - Storage BackEnds
177. Implementing S3 Storage Backend for DTR
178. Document - S3 Storage Backend
179. DTR - High Availability
180. Document - Configuring DTR HA
181. Immutable Tags in DTR
182. DTR - Caching
183. Setting Orchestrator in UCP
184. Section 6 - Security
185. Overview of Container Security Scanning
186. Configuring Container Scan with DTR
187. DTR Webhooks
188. Overview of UCP Client Bundle
189. Integrating CLI with UCP Client Bundle
190. Document - UCP Client Bundle Integration
191. Note - LDAP Video
192. Overview of LDAP
193. Integrating LDAP with UCP
194. Linux Namespaces
195. Control Groups (cgroups)
196. Limiting CPUs for Containers
197. Document - CPU Limit Commands
198. Reservation vs Limits
199. Swarm MTLS
200. Managing Secrets in Docker Swarm