Docker & Kubernetes: The Practical Guide
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!
More
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 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!
Watch Online Docker & Kubernetes: The Practical Guide
| # | Title | Duration |
|---|---|---|
| 1 | Welcome to the Course | 02:33 |
| 2 | What Is Docker? | 04:43 |
| 3 | Why Docker & Containers? | 06:00 |
| 4 | Virtual Machines vs Docker Containers | 08:56 |
| 5 | Docker Setup - Overview | 04:32 |
| 6 | Docker Setup - macOS | 03:35 |
| 7 | Docker Setup - Windows | 09:45 |
| 8 | Docker Setup - Docker Toolbox for Older Systems | 06:52 |
| 9 | An Overview of the Docker Tools | 03:06 |
| 10 | Installing & Configuring an IDE | 02:08 |
| 11 | Getting Our Hands Dirty! | 09:24 |
| 12 | Course Outline | 04:15 |
| 13 | How To Get The Most Out Of This Course | 03:25 |
| 14 | Module Introduction | 01:17 |
| 15 | Images & Containers: What and Why? | 02:30 |
| 16 | Using & Running External (Pre-Built) Images | 08:29 |
| 17 | Our Goal: A NodeJS App | 06:41 |
| 18 | Building our own Image with a Dockerfile | 11:15 |
| 19 | Running a Container based on our own Image | 07:59 |
| 20 | Images are Read-Only! | 05:52 |
| 21 | Understanding Image Layers | 08:21 |
| 22 | A First Summary | 03:19 |
| 23 | Managing Images & Containers | 02:02 |
| 24 | Stopping & Restarting Containers | 04:32 |
| 25 | Understanding Attached & Detached Containers | 07:51 |
| 26 | Entering Interactive Mode | 10:45 |
| 27 | Deleting Images & Containers | 06:27 |
| 28 | Removing Stopped Containers Automatically | 03:19 |
| 29 | A Look Behind the Scenes: Inspecting Images | 04:01 |
| 30 | Copying Files Into & From A Container | 04:59 |
| 31 | Naming & Tagging Containers and Images | 09:29 |
| 32 | Sharing Images - Overview | 06:38 |
| 33 | Pushing Images to DockerHub | 10:45 |
| 34 | Pulling & Using Shared Images | 04:51 |
| 35 | Module Summary | 05:01 |
| 36 | Module Introduction | 01:28 |
| 37 | Understanding Data Categories / Different Kinds of Data | 07:21 |
| 38 | Analyzing a Real App | 03:03 |
| 39 | Building & Understanding the Demo App | 08:37 |
| 40 | Understanding the Problem | 05:26 |
| 41 | Introducing Volumes | 02:58 |
| 42 | A First, Unsuccessful Try | 07:46 |
| 43 | Named Volumes To The Rescue! | 08:37 |
| 44 | Getting Started With Bind Mounts (Code Sharing) | 10:43 |
| 45 | Combining & Merging Different Volumes | 07:53 |
| 46 | A NodeJS-specific Adjustment: Using Nodemon in a Container | 07:17 |
| 47 | Volumes & Bind Mounts: Summary | 05:55 |
| 48 | A Look at Read-Only Volumes | 05:41 |
| 49 | Managing Docker Volumes | 07:40 |
| 50 | Using "COPY" vs Bind Mounts | 03:28 |
| 51 | Don't COPY Everything: Using "dockerignore" Files | 02:32 |
| 52 | Working with Environment Variables & ".env" Files | 08:48 |
| 53 | Using Build Arguments (ARG) | 05:10 |
| 54 | Module Summary | 05:16 |
| 55 | Module Introduction | 01:17 |
| 56 | Case 1: Container to WWW Communication | 03:51 |
| 57 | Case 2: Container to Local Host Machine Communication | 02:15 |
| 58 | Case 3: Container to Container Communication | 02:42 |
| 59 | Analyzing the Demo App | 07:51 |
| 60 | Creating a Container & Communicating to the Web (WWW) | 06:46 |
| 61 | Making Container to Host Communication Work | 04:38 |
| 62 | Container to Container Communication: A Basic Solution | 07:07 |
| 63 | Introducing Docker Networks: Elegant Container to Container Communication | 10:01 |
| 64 | How Docker Resolves IP Addresses | 02:23 |
| 65 | Module Summary | 01:27 |
| 66 | Module Introduction | 02:09 |
| 67 | Our Target App & Setup | 10:49 |
| 68 | Dockerizing the MongoDB Service | 04:27 |
| 69 | Dockerizing the Node App | 07:31 |
| 70 | Moving the React SPA into a Container | 08:27 |
| 71 | Adding Docker Networks for Efficient Cross-Container Communication | 11:51 |
| 72 | Adding Data Persistence to MongoDB with Volumes | 08:17 |
| 73 | Volumes, Bind Mounts & Polishing for the NodeJS Container | 15:03 |
| 74 | Live Source Code Updates for the React Container (with Bind Mounts) | 06:51 |
| 75 | Module Summary | 04:44 |
| 76 | Module Introduction | 03:09 |
| 77 | Docker-Compose: What & Why? | 04:35 |
| 78 | Creating a Compose File | 06:18 |
| 79 | Diving into the Compose File Configuration | 11:21 |
| 80 | Docker Compose Up & Down | 03:47 |
| 81 | Working with Multiple Containers | 14:52 |
| 82 | Adding Another Container | 05:56 |
| 83 | Building Images & Understanding Container Names | 05:26 |
| 84 | Module Summary | 02:30 |
| 85 | Module Introduction & What are "Utility Containers"? | 02:40 |
| 86 | Utility Containers: Why would you use them? | 03:03 |
| 87 | Different Ways of Running Commands in Containers | 05:57 |
| 88 | Building a First Utility Container | 04:52 |
| 89 | Utilizing ENTRYPOINT | 05:28 |
| 90 | Using Docker Compose | 06:10 |
| 91 | Module Summary | 01:32 |
| 92 | Module Introduction | 02:30 |
| 93 | The Target Setup | 07:14 |
| 94 | Adding a Nginx (Web Server) Container | 08:09 |
| 95 | Adding a PHP Container | 10:45 |
| 96 | Adding a MySQL Container | 03:22 |
| 97 | Adding a Composer Utility Container | 04:01 |
| 98 | Creating a Laravel App via the Composer Utility Container | 03:37 |
| 99 | Launching Only Some Docker Compose Services | 11:55 |
| 100 | Adding More Utility Containers | 06:26 |
| 101 | Docker Compose with and without Dockerfiles | 04:09 |
| 102 | Bind Mounts and COPY: When To Use What | 14:21 |
| 103 | Module Introduction | 03:41 |
| 104 | From Development To Production | 07:13 |
| 105 | Deployment Process & Providers | 06:27 |
| 106 | Getting Started With An Example | 04:03 |
| 107 | Bind Mounts In Production | 05:06 |
| 108 | Introducing AWS & EC2 | 02:37 |
| 109 | Connecting to an EC2 Instance | 08:24 |
| 110 | Installing Docker on a Virtual Machine | 01:57 |
| 111 | Pushing our local Image to the Cloud | 05:35 |
| 112 | Running & Publishing the App (on EC2) | 10:21 |
| 113 | Managing & Updating the Container / Image | 05:32 |
| 114 | Disadvantages of our Current Approach | 04:44 |
| 115 | From Manual Deployment to Managed Services | 05:47 |
| 116 | Deploying with AWS ECS: A Managed Docker Container Service | 14:00 |
| 117 | More on AWS | 04:13 |
| 118 | Updating Managed Containers | 03:29 |
| 119 | Preparing a Multi-Container App | 10:57 |
| 120 | Configuring the NodeJS Backend Container | 10:32 |
| 121 | Deploying a Second Container & A Load Balancer | 09:13 |
| 122 | Using a Load Balancer for a Stable Domain | 05:17 |
| 123 | Using EFS Volumes with ECS | 17:54 |
| 124 | Our Current Architecture | 01:56 |
| 125 | Databases & Containers: An Important Consideration | 05:17 |
| 126 | Moving to MongoDB Atlas | 13:46 |
| 127 | Using MongoDB Atlas in Production | 07:34 |
| 128 | Our Updated & Target Architecture | 02:26 |
| 129 | Understanding a Common Problem | 05:36 |
| 130 | Creating a "build-only" Container | 04:48 |
| 131 | Introducing Multi-Stage Builds | 07:53 |
| 132 | Building a Multi-Stage Image | 06:10 |
| 133 | Deploying a Standalone Frontend App | 15:54 |
| 134 | Development vs Production: Differences | 03:52 |
| 135 | Understanding Multi-Stage Build Targets | 02:33 |
| 136 | Beyond AWS | 02:04 |
| 137 | Module Summary | 06:44 |
| 138 | Module Introduction | 00:58 |
| 139 | Images & Containers | 03:37 |
| 140 | Key Commands | 02:15 |
| 141 | Data, Volumes & Networking | 03:14 |
| 142 | Docker Compose | 01:12 |
| 143 | Local vs Remote | 02:39 |
| 144 | Deployment | 04:29 |
| 145 | Module Introduction | 02:17 |
| 146 | More Problems with Manual Deployment | 07:42 |
| 147 | Why Kubernetes? | 05:14 |
| 148 | What Is Kubernetes Exactly? | 06:55 |
| 149 | Kubernetes: Architecture & Core Concepts | 07:38 |
| 150 | Kubernetes will NOT manage your Infrastructure! | 03:50 |
| 151 | A Closer Look at the Worker Nodes | 04:22 |
| 152 | A Closer Look at the Master Node | 02:49 |
| 153 | Important Terms & Concepts | 03:09 |
| 154 | Module Introduction | 01:26 |
| 155 | Kubernetes does NOT manage your Infrastructure | 08:42 |
| 156 | Kubernetes: Required Setup & Installation Steps | 06:27 |
| 157 | macOS Setup | 07:22 |
| 158 | Windows Setup | 12:19 |
| 159 | Understanding Kubernetes Objects (Resources) | 09:07 |
| 160 | The "Deployment" Object (Resource) | 04:04 |
| 161 | A First Deployment - Using the Imperative Approach | 12:54 |
| 162 | kubectl: Behind The Scenes | 02:15 |
| 163 | The "Service" Object (Resource) | 02:50 |
| 164 | Exposing a Deployment with a Service | 06:11 |
| 165 | Restarting Containers | 02:39 |
| 166 | Scaling in Action | 02:43 |
| 167 | Updating Deployments | 05:54 |
| 168 | Deployment Rollbacks & History | 05:41 |
| 169 | The Imperative vs The Declarative Approach | 04:13 |
| 170 | Creating a Deployment Configuration File (Declarative Approach) | 06:25 |
| 171 | Adding Pod and Container Specs | 08:49 |
| 172 | Working with Labels & Selectors | 04:44 |
| 173 | Creating a Service Declaratively | 09:30 |
| 174 | Updating & Deleting Resources | 03:42 |
| 175 | Multiple vs Single Config Files | 03:44 |
| 176 | More on Labels & Selectors | 07:50 |
| 177 | Liveness Probes | 04:12 |
| 178 | A Closer Look at the Configuration Options | 05:27 |
| 179 | Summary | 04:27 |
| 180 | Module Introduction | 02:23 |
| 181 | Starting Project & What We Know Already | 04:42 |
| 182 | Kubernetes & Volumes - More Than Docker Volumes | 03:36 |
| 183 | Kubernetes Volumes: Theory & Docker Comparison | 06:05 |
| 184 | Creating a New Deployment & Service | 09:34 |
| 185 | Getting Started with Kubernetes Volumes | 03:31 |
| 186 | A First Volume: The "emptyDir" Type | 10:05 |
| 187 | A Second Volume: The "hostPath" Type | 07:35 |
| 188 | Understanding the "CSI" Volume Type | 04:08 |
| 189 | From Volumes to Persistent Volumes | 09:09 |
| 190 | Defining a Persistent Volume | 09:05 |
| 191 | Creating a Persistent Volume Claim | 08:11 |
| 192 | Using a Claim in a Pod | 06:40 |
| 193 | Volumes vs Persistent Volumes | 06:36 |
| 194 | Using Environment Variables | 04:49 |
| 195 | Environment Variables & ConfigMaps | 06:10 |
| 196 | Module Summary | 03:00 |
| 197 | Module Introduction | 01:23 |
| 198 | Starting Project & Our Goal | 06:10 |
| 199 | Creating a First Deployment | 06:58 |
| 200 | Another Look at Services | 09:39 |
| 201 | Multiple Containers in One Pod | 08:33 |
| 202 | Pod-internal Communication | 04:30 |
| 203 | Creating Multiple Deployments | 05:55 |
| 204 | Pod-to-Pod Communication with IP Addresses & Environment Variables | 07:28 |
| 205 | Using DNS for Pod-to-Pod Communication | 05:22 |
| 206 | Which Approach Is Best? And a Challenge! | 03:10 |
| 207 | Challenge Solution | 10:07 |
| 208 | Adding a Containerized Frontend | 14:08 |
| 209 | Deploying the Frontend with Kubernetes | 07:53 |
| 210 | Using a Reverse Proxy for the Frontend | 13:58 |
| 211 | Module Summary | 01:53 |
| 212 | Module Introduction | 01:51 |
| 213 | Deployment Options & Steps | 05:43 |
| 214 | AWS EKS vs AWS ECS | 02:50 |
| 215 | Preparing the Starting Project | 07:41 |
| 216 | Diving Into AWS | 03:06 |
| 217 | Creating & Configuring the Kubernetes Cluster with EKS | 15:45 |
| 218 | Adding Worker Nodes | 08:49 |
| 219 | Applying Our Kubernetes Config | 07:57 |
| 220 | Getting Started with Volumes | 05:00 |
| 221 | Adding EFS as a Volume (with the CSI Volume Type) | 04:35 |
| 222 | Creating a Persistent Volume for EFS | 08:24 |
| 223 | Using the EFS Volume | 08:10 |
| 224 | A Challenge! | 03:26 |
| 225 | Challenge Solution | 14:48 |
| 226 | You Learned A Lot! | 03:24 |
| 227 | Related Topics You Could Explore | 07:09 |
| 228 | Next Steps! | 03:07 |
| 229 | Course Roundup | 00:56 |
Similar courses to Docker & Kubernetes: The Practical Guide
Ultimate Service 3.0
Master Microservices with Java, Spring, Docker, Kubernetes
Kubernetes CKS 2023 Complete Course + Simulator
React and NestJS: A Practical Guide with Docker
Kubernetes Hands-On - Deploy Microservices to the AWS Cloud
Istio Hands-On for Kubernetes
DevOps Deployment Automation with Terraform, AWS and Docker
