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

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

-

Docker & Kubernetes are amongst the most in-demand technologies and topics you can learn these days.

Why?

Because they significantly simplify the development and deployment process of both simple and complex software projects. Especially in web development (though not limited to that), Docker can really take you to the next level!

With Docker, you create and manage so-called "Containers" - basically packages of code and tools required to run that code. These containers allow you to run your programs in a predictable, environment-independent way - no matter where you need to run it.

For modern DevOps (Development Operations) but also for local development - on your own or in a team - this is a winner feature since you will no longer have any "but it worked on my machine" discussions. It works inside of a container, hence it works everywhere!

This course will teach you both Docker & Kubernetes from the ground up with all the required theory and tons of examples and demos!

We'll explore all key concepts in detail and with practical examples and demos - from images and containers, over volumes and networking all the way up to deployment and Kubernetes Cluster: This course has it all!

In detail, this course includes the following topics:

• A thorough introduction to Docker, containers and why you might want to use Docker

• Detailed setup instructions for macOS and Windows

• A deep-dive into the core concepts you need to know: Containers & images

• Learn how to create custom images, use existing images and how to run containers based on such images

• Get a detailed overview of the core commands you need when working with Docker

• Learn how to work with data and how to persist data with volumes

• Explore container networking - with the outside world and between multiple containers

• Learn how to work with both single and multi-container projects

• In-depth deployment instructions: Manual deployment and deployment with managed services like AWS ECS

• Understand Kubernetes core concepts & architecture

• Learn how to create Kubernetes resources, deployments, services and how to run your containers with Kubernetes

• Dive deeply into working with data in Kubernetes projects - with different types of volumes

• Kubernetes networking and DNS service discovery

• Learn how to deploy your Kubernetes project (at the example of AWS EKS)

• And much more!

All these topics are taught in great detail with slides and theory but also, most importantly, with many examples and demo!

You'll find tons of demo projects throughout the course - using programming languages like NodeJS, Python or PHP (with Laravel). You don't need to know these languages to follow along though, no worries!

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

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 setup and get started with Docker. The coding exercises that accompany this course will help you practice Docker commands and developing 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 setup 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 test. You will be given a challenge to solve using the skills you gained during this course. This is a great way to gain a 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.

This course is designed for beginners in DevOps

Legal Notice:

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

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 Slack 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. Important: How to Access 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

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

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

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

This is the ultimate course to learn how to deploy any web application you can possibly dream up.  Docker and Kubernetes are the newest tech in the Dev Ops world, and have dramatically changed the flow of creating and deploying web apps.  Docker is a technology that allows applications to run in constructs called 'containers', while Kubernetes allows for many different 'containers' to run in coordination.

Docker from Scratch!

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

CI + CD Pipelines

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

Multi-Container Deployments on AWS!

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

Kubernetes!

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

Here's what you'll do:

• Learn Docker from scratch, no previous experience required

• Build your own custom images tailored to your applications

• Master the Docker CLI to inspect and debug running containers

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

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

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

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

• Understand the purpose and theory of Kubernetes

• Deploy a production-ready Kubernetes Cluster to Google Cloud

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

Docker is a powerful tool for packaging, shipping and running applications in docker containers. It makes the process of deploying application super easy.

Deploying an application with docker is as easy as running a simple docker run command

This course will take you in a step-by-step way to start working the docker cli to manage docker containers, docker images and to build your own docker images

By taking this course you will have the required skills that you need to start building your own images and playing with docker container, learn advanced docker topics or learn one the orchestration tools like Docker Swarm, MESOS or Kubernetes which is the most popular orchestration tool

Requirements for this Course:

• Basic Linux knowledge

  
  

Who this course is for:

• The course is  for developers who wants to start learning the DevOps tool known as Docker

• This course is ideal for people who are new to DevOps and who want to start their career in DevOps

  
  

  
  

What you’ll learn

• what is docker and why we need it?

• Docker images VS docker containers

• Working with docker images

• Working with docker containers

• Working with docker volumes

• Build your own docker image

• Store your docker images in your Dockerhub account

1. Course introduction
2. Introduction
3. What is docker? and why we need it?
4. Docker images VS docker containers
5. Working with docker images
6. Installing docker
7. Pull - list - remove docker images
8. Working with docker containers
9. Run - stop - remove docker containers
10. Execute commands in docker containers
11. Run a container in attached or detached mode
12. Port mapping in docker
13. Working with docker volumes
14. Create - list - remove docker volumes
15. How the data is stored by containers without docker volumes
16. Mounting a docker volume to a docker container
17. Creating docker images
18. Building a docker image using Dockerfile
19. Dockerize a Flask application
20. Push the image to Docker Hub